cecli-dev 1.8.1rc3__tar.gz → 1.9.0__tar.gz

{cecli_dev-1.8.1rc3 → cecli_dev-1.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.8.1rc3
+Version: 1.9.0
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-1.8.1rc3 → cecli_dev-1.9.0}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.8.1rc3'
-__version_tuple__ = version_tuple = (1, 8, 1, 'rc3')
+__version__ = version = '1.9.0'
+__version_tuple__ = version_tuple = (1, 9, 0)
 
-__commit_id__ = commit_id = 'gb07a9f6ad'
+__commit_id__ = commit_id = 'g2f5bc6842'

{cecli_dev-1.8.1rc3 → cecli_dev-1.9.0}/cecli/args.py

@@ -31,6 +31,7 @@ DEEP_MERGE_LIST_FIELDS: frozenset[str] = frozenset(
         "file",
         "read",
         "mcp_servers_files",
+        "acp_models",
         "set_env",
         "api_key",
         "alias",
@@ -1313,6 +1314,24 @@ def get_parser(default_config_files, git_root):
         help="Specify server configuration (WebSocket and headless) as a JSON/YAML string",
         default=None,
     )
+    group.add_argument(
+        "--acp",
+        action="store_true",
+        default=False,
+        help=(
+            "Run as an Agent Client Protocol (ACP) agent over stdio, for editors such as Zed"
+            " (stdout carries the protocol)"
+        ),
+    )
+    group.add_argument(
+        "--acp-models",
+        action="append",
+        metavar="PATTERN",
+        help=(
+            "Limit the ACP model picker's provider lists to models matching this pattern,"
+            " matched like /models (can be used multiple times)"
+        ),
+    )
 
     ##########
     group = parser.add_argument_group("Deprecated model settings")

{cecli_dev-1.8.1rc3 → cecli_dev-1.9.0}/cecli/coders/agent_coder.py

@@ -842,6 +842,7 @@ class AgentCoder(Coder):
         for tool_call in tool_calls_list:
             tool_name = tool_call.function.name
             result_message = ""
+            self.io.tool_call_event(tool_call.id, "in_progress")
             try:
                 if responses.unprefix_tool_name(tool_name)[1].lower() in self.write_tools:
                     used_write_tool = True

{cecli_dev-1.8.1rc3 → cecli_dev-1.9.0}/cecli/coders/base_coder.py

@@ -291,8 +291,8 @@ class Coder(metaclass=UsageMeta):
     commit_language = None
     file_watcher = None
     mcp_manager = None
-    run_one_completed = True
     compact_context_completed = True
+    _drain_queue_after_command = False
     suppress_announcements_for_next_prompt = False
     tool_reflection = False
     last_user_message = ""
@@ -684,6 +684,8 @@ class Coder(metaclass=UsageMeta):
         self._queue_counter = 0
         self._queue_lock = threading.Lock()
         self._processing_queue = False
+        self._active_queue_prompt = None
+        self._drain_queue_after_command = False
 
         self.data_cache = {
             "repo": {"last_key": "", "read_only_count": None},
@@ -1627,6 +1629,10 @@ class Coder(metaclass=UsageMeta):
         async for chunk in self.send_message(user_message):
             yield chunk
 
+        # Stream-driven interfaces bypass run_one(), so drain the queue here
+        # to keep queued prompts processing after the request completes.
+        await self.process_prompt_queue()
+
     def init_before_message(self):
         self.coder_edited_files = set()
         self.reflected_message = None
@@ -1946,14 +1952,12 @@ class Coder(metaclass=UsageMeta):
                     await self.compact_context_if_needed()
                     self.compact_context_completed = True
 
-            self.run_one_completed = False
             await self.run_one(user_message, preproc)
             self.show_undo_hint()
         except asyncio.CancelledError:
             # Don't show undo hint if cancelled
             raise
         finally:
-            self.run_one_completed = True
             self.compact_context_completed = True
             self.io.stop_spinner()
             # Trim memory in the background so it doesn't stall the event loop
@@ -2013,9 +2017,6 @@ class Coder(metaclass=UsageMeta):
             try:
                 return await self.commands.run(inp, coder=self, **run_kwargs)
             finally:
-                # Dispatch can return early (unknown/ambiguous command) or
-                # raise without ever running a command; the gate must still be
-                # reopened or the input/output loops park forever.
                 self.commands.cmd_running_event.set()
 
         await self.check_for_file_mentions(inp)
@@ -2026,6 +2027,67 @@ class Coder(metaclass=UsageMeta):
     def wrap_user_input(self, inp):
         return inp
 
+    async def process_prompt_queue(self, preproc=True):
+        """Drain the coder's prompt queue in FIFO order.
+
+        Re-entrant calls return immediately. Each item is activated before it
+        runs so an interrupt can put it back at the front of the queue, and
+        failures are isolated so one prompt does not abort the rest.
+        """
+        if self._processing_queue:
+            return
+
+        def warn_paused():
+            remaining = command_queue.get_queue_length(self)
+            self.io.tool_warning(
+                f"Queue processing interrupted. {remaining} prompt(s) remain"
+                " queued; use /run-queue to resume."
+            )
+
+        from cecli.helpers.agents.service import AgentService
+
+        self._processing_queue = True
+        try:
+            while True:
+                item = command_queue.dequeue_for_processing(self)
+                if item is None:
+                    break
+
+                self.io.tool_output(f"Processing queued prompt (id: {item['id']})...")
+                try:
+                    await self.generate(item["text"], preproc)
+                    interrupt_event = getattr(self, "interrupt_event", None)
+                    if interrupt_event is not None and interrupt_event.is_set() is True:
+                        command_queue.requeue_active_prompt(self)
+                        warn_paused()
+                        break
+                except (asyncio.CancelledError, KeyboardInterrupt):
+                    command_queue.requeue_active_prompt(self)
+                    warn_paused()
+                    raise
+                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)
+                    self.io.tool_error(f"Error processing queued prompt (id: {item['id']}): {e}")
+                    continue
+
+                command_queue.clear_active_prompt(self)
+        finally:
+            self._drain_queue_after_command = False
+            command_queue.finish_processing(self)
+
     async def run_one(self, user_message, preproc):
         self.init_before_message()
 
@@ -2041,6 +2103,9 @@ class Coder(metaclass=UsageMeta):
         if self.commands.is_command(user_message) and not self.commands.is_test_command(
             user_message
         ):
+            if self._processing_queue or self._drain_queue_after_command:
+                self._drain_queue_after_command = False
+                await self.process_prompt_queue(preproc)
             return
 
         if not self.commands.is_command(user_message):
@@ -2112,19 +2177,10 @@ class Coder(metaclass=UsageMeta):
 
             await self.auto_save_session(force=True)
 
-        # Move to the next queued prompt (CLI-33) only after the current message
-        # has fully completed, so the queue drains within run_one() instead of
+        # Drain any queued prompts (CLI-33) only after the current message has
+        # fully completed, so the queue is processed within run_one() instead of
         # being watched by the generation loops.
-        if self.prompt_queue and not self._processing_queue:
-            self._processing_queue = True
-            try:
-                item = command_queue.dequeue_prompt(self)
-            finally:
-                self._processing_queue = False
-
-            if item is not None:
-                self.io.tool_output(f"Processing queued prompt (id: {item['id']})...")
-                await self.run_one(item["text"], preproc)
+        await self.process_prompt_queue(preproc)
 
         if not await HookIntegration.call_end_hooks(self):
             self.io.tool_warning("Execution stopped by end hook")
@@ -3284,6 +3340,7 @@ class Coder(metaclass=UsageMeta):
                     continue
 
                 tool_id_set.add(tool_call.id)
+                self.io.tool_call_event(tool_call.id, "in_progress")
 
                 try:
                     # Arguments can be a stream of JSON objects.
@@ -3490,6 +3547,11 @@ class Coder(metaclass=UsageMeta):
         for server, server_responses in tool_responses_by_server.items():
             for tool_response in server_responses:
                 tool_responses.append(tool_response)
+                self.io.tool_call_event(
+                    tool_response["tool_call_id"],
+                    "completed",
+                    result=tool_response.get("content"),
+                )
 
                 ConversationService.get_manager(self).add_message(
                     message_dict=tool_response,
@@ -3507,6 +3569,12 @@ class Coder(metaclass=UsageMeta):
 
         for server, tool_calls in server_tool_calls.items():
             for tool_call in tool_calls:
+                self.io.tool_call_event(
+                    tool_call.id,
+                    "pending",
+                    name=tool_call.function.name,
+                    arguments=tool_call.function.arguments,
+                )
                 try:
                     if ToolRegistry.get_tool(tool_call.function.name.lower()):
                         ToolRegistry.get_tool(tool_call.function.name.lower()).format_output(
@@ -4828,7 +4896,7 @@ class Coder(metaclass=UsageMeta):
         if self.tui and self.tui():
             self.tui().update_cost(self.usage_report.replace("\n", " "))
         else:
-            self.io.tool_output(self.usage_report)
+            self.io.tool_output(self.usage_report, type="usage-report")
             self.io.rule()
 
         self.message_cost = 0.0

{cecli_dev-1.8.1rc3 → cecli_dev-1.9.0}/cecli/commands/__init__.py

@@ -73,6 +73,7 @@ from .report import ReportCommand
 from .reset import ResetCommand
 from .rules import RulesCommand
 from .run import RunCommand
+from .run_queue import RunQueueCommand
 from .save import SaveCommand
 from .save_session import SaveSessionCommand
 from .search_memory import SearchMemoryCommand
@@ -169,6 +170,7 @@ CommandRegistry.register(ReportCommand)
 CommandRegistry.register(ResetCommand)
 CommandRegistry.register(RulesCommand)
 CommandRegistry.register(RunCommand)
+CommandRegistry.register(RunQueueCommand)
 CommandRegistry.register(SaveCommand)
 CommandRegistry.register(SaveSessionCommand)
 CommandRegistry.register(SearchMemoryCommand)
@@ -265,6 +267,7 @@ __all__ = [
     "ResetCommand",
     "RulesCommand",
     "RunCommand",
+    "RunQueueCommand",
     "SaveCommand",
     "SaveSessionCommand",
     "SearchMemoryCommand",

{cecli_dev-1.8.1rc3 → cecli_dev-1.9.0}/cecli/commands/core.py

@@ -14,6 +14,9 @@ from cecli.signals import SwitchCoderSignal
 class Commands:
     scraper = None
 
+    # Commands that receive their full argument text for nested completion.
+    FULL_ARGS_COMPLETION_COMMANDS = ("/queue", "/insert-queue")
+
     def _get_coder(self):
         """Return coder via weak reference, or None if collected."""
         if self._coder_ref is not None:
@@ -90,7 +93,7 @@ class Commands:
         self.last_command_show_notification = True
 
         # Commands that should NOT trigger auto-processing of the queue
-        self._MANAGEMENT_COMMANDS = {"queue", "list-queue", "remove-queue"}
+        self._MANAGEMENT_COMMANDS = {"queue", "list-queue", "remove-queue", "run-queue"}
 
     def _load_custom_commands(self, custom_commands):
         """

{cecli_dev-1.8.1rc3 → cecli_dev-1.9.0}/cecli/commands/insert_queue.py

@@ -60,6 +60,7 @@ class InsertQueueCommand(BaseCommand):
         try:
             item = command_queue.insert_prompt(coder, prompt_text, index)
             io.tool_output(f"Prompt inserted at position {index + 1} (id: {item['id']})")
+
             return f"Successfully executed {cls.NORM_NAME}."
         except ValueError as e:
             return format_command_result(io, cls.NORM_NAME, "", error=str(e))
@@ -68,8 +69,20 @@ class InsertQueueCommand(BaseCommand):
 
     @classmethod
     def get_completions(cls, io, coder, args) -> List[str]:
-        """Get completion options for insert-queue command."""
-        return []
+        """Get completion options for insert-queue command.
+
+        Args are "<index> <prompt text>"; once the index token and a space
+        are present, mirror the nested prompt's completions (e.g. a nested
+        slash command delegates to the original command's completions).
+        """
+        text = args or ""
+        first_space = text.find(" ")
+        if first_space == -1:
+            # Still typing the index; suggest valid positions.
+            if not coder.commands:
+                return []
+            return [str(i) for i in range(1, command_queue.get_queue_length(coder) + 2)]
+        return command_queue.nested_command_completions(coder, text[first_space + 1 :])
 
     @classmethod
     def get_help(cls) -> str:
@@ -83,5 +96,5 @@ class InsertQueueCommand(BaseCommand):
         help_text += "\nExamples:\n"
         help_text += "  /insert-queue 1 Review the changes in src/main.py\n"
         help_text += "  /insert-queue 3 Write unit tests for the new feature\n"
-        help_text += "\nSee also: /queue, /list-queue, /remove-queue\n"
+        help_text += "\nSee also: /queue, /list-queue, /remove-queue, /run-queue\n"
         return help_text

{cecli_dev-1.8.1rc3 → cecli_dev-1.9.0}/cecli/commands/list_queue.py

@@ -66,5 +66,5 @@ class ListQueueCommand(BaseCommand):
         help_text += "  and the time it was queued.\n"
         help_text += "\nExamples:\n"
         help_text += "  /list-queue  # Shows all queued prompts\n"
-        help_text += "\nSee also: /queue, /remove-queue\n"
+        help_text += "\nSee also: /queue, /insert-queue, /remove-queue, /run-queue\n"
         return help_text

{cecli_dev-1.8.1rc3 → cecli_dev-1.9.0}/cecli/commands/queue.py

@@ -59,6 +59,7 @@ class QueueCommand(BaseCommand):
             item = command_queue.enqueue_prompt(coder, prompt_text)
             position = command_queue.get_queue_length(coder)
             io.tool_output(f"Prompt queued at position {position} (id: {item['id']})")
+
             return f"Successfully executed {cls.NORM_NAME}."
         except ValueError as e:
             return format_command_result(io, cls.NORM_NAME, "", error=str(e))
@@ -67,8 +68,12 @@ class QueueCommand(BaseCommand):
 
     @classmethod
     def get_completions(cls, io, coder, args) -> List[str]:
-        """Get completion options for queue command."""
-        return []
+        """Get completion options for queue command.
+
+        When the queued prompt starts with a slash command, mirror the
+        original command's completions (e.g. /queue /add <tab> offers files).
+        """
+        return command_queue.nested_command_completions(coder, args)
 
     @classmethod
     def get_help(cls) -> str:
@@ -86,5 +91,5 @@ class QueueCommand(BaseCommand):
         help_text += "\nExamples:\n"
         help_text += "  /queue Review the changes in src/main.py\n"
         help_text += "  /queue Write unit tests for the new feature\n"
-        help_text += "\nSee also: /list-queue, /remove-queue\n"
+        help_text += "\nSee also: /insert-queue, /list-queue, /remove-queue, /run-queue\n"
         return help_text

{cecli_dev-1.8.1rc3 → cecli_dev-1.9.0}/cecli/commands/remove_queue.py

@@ -115,5 +115,5 @@ class RemoveQueueCommand(BaseCommand):
         help_text += "  /remove-queue 1   # Remove the first queued prompt\n"
         help_text += "  /remove-queue *   # Clear the entire queue\n"
         help_text += "  /remove-queue     # Interactive mode\n"
-        help_text += "\nSee also: /queue, /list-queue\n"
+        help_text += "\nSee also: /queue, /insert-queue, /list-queue, /run-queue\n"
         return help_text

cecli_dev-1.9.0/cecli/commands/run_queue.py

@@ -0,0 +1,79 @@
+"""Run-queue command for CLI-33: processes queued prompts on demand.
+
+Primary use: after cancelling an in-flight response (Ctrl+C), the in-flight
+prompt is re-queued at the front. /run-queue resumes processing the queue.
+"""
+
+import asyncio
+from typing import List
+
+from cecli.commands.utils.base_command import BaseCommand
+from cecli.commands.utils.helpers import format_command_result
+from cecli.helpers import command_queue
+from cecli.signals import SwitchCoderSignal
+
+
+class RunQueueCommand(BaseCommand):
+    NORM_NAME = "run-queue"
+    DESCRIPTION = "Process queued prompts in order"
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """Execute the run-queue command with given parameters.
+
+        Args:
+            io: InputOutput instance
+            coder: Coder instance (may be None for some commands)
+            args: Command arguments (unused for run-queue)
+            **kwargs: Additional context
+
+        Returns:
+            Formatted result string
+        """
+        # Sad path: coder.commands is None
+        if not coder.commands:
+            return format_command_result(
+                io, cls.NORM_NAME, "", error="Command system not available. Cannot run queue."
+            )
+
+        # Resolve the target coder (sub-agent aware: use the foreground agent's queue)
+        target = command_queue.get_active_coder(coder)
+
+        # Sad path: empty queue
+        if command_queue.get_queue_length(target) == 0:
+            io.tool_output("Queue is empty. Use /queue <prompt> to add prompts first.")
+            return f"Successfully executed {cls.NORM_NAME}."
+
+        # Happy path: drain the queue
+        try:
+            await target.process_prompt_queue()
+            return f"Successfully executed {cls.NORM_NAME}."
+        except (KeyboardInterrupt, asyncio.CancelledError):
+            # The interrupted item was re-queued; let the user know the queue paused.
+            io.tool_output("Queue processing paused. Use /run-queue to resume.")
+            return f"Successfully executed {cls.NORM_NAME}."
+        except (SwitchCoderSignal, SystemExit):
+            raise
+        except Exception as e:
+            return format_command_result(io, cls.NORM_NAME, "", error=str(e))
+
+    @classmethod
+    def get_completions(cls, io, coder, args) -> List[str]:
+        """Get completion options for run-queue command."""
+        return []
+
+    @classmethod
+    def get_help(cls) -> str:
+        """Get help text for the run-queue command."""
+        help_text = super().get_help()
+        help_text += "\nUsage:\n"
+        help_text += "  /run-queue  # Process all queued prompts in FIFO order\n"
+        help_text += "\nDescription:\n"
+        help_text += "  Processes every prompt currently in the queue, in order.\n"
+        help_text += "  Queued prompts normally run automatically after the current\n"
+        help_text += "  response finishes. Use /run-queue to resume a queue that was\n"
+        help_text += "  paused (e.g. after cancelling an in-flight response with Ctrl+C).\n"
+        help_text += "\nExamples:\n"
+        help_text += "  /run-queue  # Drains the queue, processing each prompt in order\n"
+        help_text += "\nSee also: /queue, /insert-queue, /list-queue, /remove-queue\n"
+        return help_text

{cecli_dev-1.8.1rc3 → cecli_dev-1.9.0}/cecli/helpers/agents/service.py

@@ -41,6 +41,25 @@ MODEL_SENTINEL_CURRENT = "<current>"
 AGENT_INHERIT_PREFIXES = ("ws:", "wf:")
 
 
+def _subagent_event(coder: Any, agent_uuid: Any, event: str, **kwargs: Any) -> None:
+    """Report a sub-agent's lifecycle to the IO (see ``InputOutput.subagent_event``)."""
+    io = getattr(coder, "io", None)
+    if io is None:
+        return
+    try:
+        io.subagent_event(str(agent_uuid), event, **kwargs)
+    except Exception:
+        logger.warning("Failed to report sub-agent event %r", event, exc_info=True)
+
+
+def _was_cancelled(info: "SubAgentInfo") -> bool:
+    """Whether the current run was cancelled, even if the coder absorbed it as a ^C."""
+    if info.cancel_requested:
+        return True
+    cancelling = getattr(asyncio.current_task(), "cancelling", None)  # Python 3.11+
+    return bool(cancelling and cancelling())
+
+
 class SubAgentStatus(Enum):
     """Status of a sub-agent."""
 
@@ -66,6 +85,7 @@ class SubAgentInfo:
     auto_reap: bool = True  # If True, agent may be automatically reaped when FINISHED
     independent: bool = False
     detached: bool = False
+    cancel_requested: bool = False  # the current run was cancelled (see _was_cancelled)
 
 
 class AgentService:
@@ -522,6 +542,8 @@ class AgentService:
         except (AttributeError, RuntimeError):
             logger.warning("Failed to notify TUI to remove sub-agent container", exc_info=True)
 
+        _subagent_event(self.coder, info.coder.uuid, "removed")
+
         # Cancel any tracked generate task to avoid floating tasks
         if info.generate_task is not None and not info.generate_task.done():
             info.generate_task.cancel()
@@ -733,6 +755,16 @@ class AgentService:
         except Exception:
             logger.warning("Failed to notify TUI to create sub-agent container", exc_info=True)
 
+        _subagent_event(
+            parent_coder,
+            new_coder.uuid,
+            "created",
+            parent_uuid=str(parent_coder.uuid),
+            name=name,
+            description=metadata.get("description") if isinstance(metadata, dict) else None,
+            root=str(getattr(new_coder, "root", "") or ""),
+        )
+
         # Initialize system prompt from config
         system_prompt = getattr(config, "prompt", "")
         from cecli.helpers.conversation.service import ConversationService
@@ -774,6 +806,40 @@ class AgentService:
     # 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.
 
@@ -807,8 +873,14 @@ class AgentService:
 
         async def _run_generate():
             info.status = SubAgentStatus.RUNNING
+            info.cancel_requested = False
+            _subagent_event(info.coder, info.coder.uuid, "running")
+            stop_reason, error = "end_turn", None
             try:
                 await info.coder.generate(user_message=user_message, preproc=True)
+                if _was_cancelled(info):
+                    stop_reason = "cancelled"
+                    info.summary = info.summary or DEFAULT_SUMMARY_INTERRUPTED
                 await self._inject_sub_agent_result(info)
                 if info.status == SubAgentStatus.RUNNING:
                     info.status = SubAgentStatus.FINISHED
@@ -831,12 +903,14 @@ class AgentService:
                     fire_and_forget(_cleanup())
 
             except asyncio.CancelledError:
+                stop_reason = "cancelled"
                 await self._inject_sub_agent_result(info)
                 info.status = SubAgentStatus.FINISHED
                 info.summary = info.summary or DEFAULT_SUMMARY_INTERRUPTED
                 logger.debug("Sub-agent %s generate cancelled (interrupted)", info.name)
                 raise
             except Exception as exc:
+                stop_reason, error = "error", str(exc) or exc.__class__.__name__
                 await self._inject_sub_agent_result(info)
                 info.status = SubAgentStatus.ERROR
                 info.error = str(exc)
@@ -849,6 +923,10 @@ class AgentService:
                 raise
             except SwitchCoderSignal:
                 raise
+            finally:
+                _subagent_event(
+                    info.coder, info.coder.uuid, "idle", stop_reason=stop_reason, error=error
+                )
 
         # Cancel any previous generate task to prevent duplicate concurrent generates
         if info.generate_task is not None and not info.generate_task.done():
@@ -986,6 +1064,10 @@ class AgentService:
                 force=True,
             )
 
+        _subagent_event(
+            parent_coder, parent_coder.uuid, "message", sender_uuid=coder_uuid, text=user_content
+        )
+
     async def invoke(
         self,
         name: str,
@@ -1011,8 +1093,23 @@ class AgentService:
             return None
 
         # Blocking: run the sub-agent with the prompt using start_generate_task
+        sender = parent if parent is not None else self.coder
+        _subagent_event(
+            sender, new_coder.uuid, "message", sender_uuid=str(sender.uuid), text=prompt
+        )
         task = self.start_generate_task(info, prompt)
-        await task
+        try:
+            await asyncio.shield(task)
+        except asyncio.CancelledError:
+            if info.cancel_requested or task.cancelled():
+                # The sub-agent was cancelled; wait for its interrupted summary
+                await asyncio.gather(task, return_exceptions=True)
+                return info.summary
+
+            # The caller was cancelled: stop the sub-agent it was waiting for
+            info.cancel_requested = True
+            task.cancel()
+            raise
         return info.summary
 
     async def spawn(
@@ -1040,6 +1137,10 @@ class AgentService:
             name, auto_reap=auto_reap, parent=parent, independent=independent
         )
         if prompt:
+            sender = parent if parent is not None else self.coder
+            _subagent_event(
+                sender, new_coder.uuid, "message", sender_uuid=str(sender.uuid), text=prompt
+            )
             self.start_generate_task(info, prompt)
         return new_coder, info
 
@@ -1079,6 +1180,19 @@ class AgentService:
 
         return [info.summary for info in children]
 
+    def cancel_sub_agent(self, agent_uuid: str) -> bool:
+        """Stop a sub-agent's current work, leaving its parent running.
+
+        A parent waiting on it (a blocking delegation) gets the interrupted
+        summary. Returns False if the sub-agent was not working.
+        """
+        info = self.sub_agents.get(str(agent_uuid))
+        if info is None or info.generate_task is None or info.generate_task.done():
+            return False
+        info.cancel_requested = True
+        info.generate_task.cancel()
+        return True
+
     def get_active_agents(self) -> List[Dict[str, Any]]:
         """Return list of active sub-agents for display."""
         return [