Handle commands the update the coder class in prompt queue feature

Author: dwash96

cecli/coders/base_coder.py

@@ -2044,6 +2044,8 @@ def warn_paused():
                 " queued; use /run-queue to resume."
             )
 
+        from cecli.helpers.agents.service import AgentService
+
         self._processing_queue = True
         try:
             while True:
@@ -2063,7 +2065,18 @@ def warn_paused():
                     command_queue.requeue_active_prompt(self)
                     warn_paused()
                     raise
-                except (SwitchCoderSignal, SystemExit):
+                except SwitchCoderSignal as switch:
+                    if not getattr(self, "parent_uuid", ""):
+                        raise
+
+                    service = AgentService.get_instance(self)
+                    info = service.sub_agents.get(self.uuid)
+                    if info is None:
+                        raise
+
+                    await service.switch_sub_agent_coder(info, switch, preproc)
+                    return
+                except SystemExit:
                     raise
                 except Exception as e:
                     command_queue.clear_active_prompt(self)

cecli/helpers/agents/service.py

@@ -806,6 +806,40 @@ async def _create_sub_agent_coder(
     # Public API
     # ------------------------------------------------------------------ #
 
+    async def switch_sub_agent_coder(self, info: SubAgentInfo, switch, preproc=True) -> Any:
+        """Atomically hand a sub-agent's remaining queue to a replacement coder.
+
+        Commands such as /add request a coder rebuild by raising SwitchCoderSignal.
+        A sub-agent must absorb that signal locally: letting it escape recreates the
+        primary coder from the sub-agent and leaves the main session in sub-agent
+        mode. The active prompt has already run, so only the remaining queue moves.
+        """
+        from cecli.coders import Coder
+        from cecli.helpers import command_queue
+
+        old_coder = info.coder
+        kwargs = dict(io=old_coder.io, from_coder=old_coder)
+        kwargs.update(switch.kwargs)
+        kwargs.pop("show_announcements", None)
+        kwargs["from_coder"] = old_coder
+        kwargs["args"] = old_coder.args
+        kwargs["summarize_from_coder"] = False
+
+        new_coder = await Coder.create(**kwargs)
+
+        new_coder.prompt_queue = list(old_coder.prompt_queue)
+        new_coder._queue_counter = old_coder._queue_counter
+        old_coder.prompt_queue.clear()
+
+        command_queue.clear_active_prompt(old_coder)
+
+        info.coder = new_coder
+        self.sub_agents[new_coder.uuid] = info
+        self._uuid_coder_map[new_coder.uuid] = weakref.ref(new_coder)
+
+        await new_coder.process_prompt_queue(preproc)
+        return new_coder
+
     def start_generate_task(self, info: SubAgentInfo, user_message: str) -> asyncio.Task:
         """Start a sub-agent's generate task in the background with status management.
 

tests/commands/test_queue_commands.py

@@ -2,7 +2,7 @@
 
 import threading
 import time
-from unittest.mock import MagicMock
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
@@ -813,6 +813,77 @@ async def swallowed_interrupt_generate(text, preproc=True):
         mock_io.tool_warning.assert_called_once()
 
 
+class TestSubAgentCoderSwitch:
+    """A sub-agent's queued command signal swaps coders instead of escaping."""
+
+    @pytest.mark.asyncio
+    async def test_process_prompt_queue_moves_queue_to_replacement_coder(self, mock_io):
+        """A SwitchCoderSignal from a queued command switches only the sub-agent."""
+        from cecli.coders.base_coder import Coder
+
+        coder = _make_coder_with_commands(("raises-switch", "second", "third"))
+        coder.uuid = "sub-uuid"
+        coder.parent_uuid = "primary-uuid"
+        coder.io = mock_io
+        coder.args = MagicMock()
+
+        async def signal_generate(text, preproc=True):
+            raise SwitchCoderSignal(edit_format="subagent", from_coder=coder)
+
+        coder.generate = AsyncMock(side_effect=signal_generate)
+
+        new_coder = MagicMock()
+        new_coder.uuid = "sub-uuid"
+        new_coder.process_prompt_queue = AsyncMock()
+
+        from cecli.helpers.agents.service import AgentService, SubAgentInfo
+
+        parent = MagicMock()
+        parent.uuid = "primary-uuid"
+        service = AgentService(parent)
+        info = SubAgentInfo(name="wf:storytime", coder=coder, parent_uuid="primary-uuid")
+        service.sub_agents["sub-uuid"] = info
+        service._sub_agent_order.append("sub-uuid")
+
+        with (
+            patch("cecli.coders.Coder.create", AsyncMock(return_value=new_coder)) as create,
+            patch("cecli.helpers.agents.service.AgentService.get_instance", return_value=service),
+        ):
+            await Coder.process_prompt_queue(coder)
+
+        assert [item["text"] for item in new_coder.prompt_queue] == ["second", "third"]
+        assert coder.prompt_queue == []
+        assert info.coder is new_coder
+        assert service.sub_agents["sub-uuid"] is info
+        assert coder._processing_queue is False
+        assert command_queue.get_active_prompt(coder) is None
+        new_coder.process_prompt_queue.assert_awaited_once_with(True)
+
+        create_kwargs = create.call_args.kwargs
+        assert create_kwargs["from_coder"] is coder
+
+    @pytest.mark.asyncio
+    async def test_process_prompt_queue_reraises_switch_for_primary(self, mock_io):
+        """A primary coder still propagates its own SwitchCoderSignal."""
+        from cecli.coders.base_coder import Coder
+
+        coder = _make_coder_with_commands(("raises-switch",))
+        coder.uuid = "primary-uuid"
+        coder.parent_uuid = ""
+        coder.io = mock_io
+        coder.args = MagicMock()
+
+        async def signal_generate(text, preproc=True):
+            raise SwitchCoderSignal(edit_format="agent", from_coder=coder)
+
+        coder.generate = AsyncMock(side_effect=signal_generate)
+
+        with pytest.raises(SwitchCoderSignal):
+            await Coder.process_prompt_queue(coder)
+
+        assert coder._processing_queue is False
+
+
 class TestTUICompletionApplication:
     """Applying nested completions must preserve the host and inner command."""