klaude-code 2.0.1__py3-none-any.whl → 2.1.0__py3-none-any.whl

klaude_code/core/executor.py

@@ -10,22 +10,22 @@ from __future__ import annotations
 import asyncio
 import subprocess
 import sys
-from collections.abc import Callable
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 from pathlib import Path
 
 from klaude_code.config import load_config
-from klaude_code.core.agent import Agent, DefaultModelProfileProvider, ModelProfileProvider
+from klaude_code.core.agent import Agent
+from klaude_code.core.agent_profile import DefaultModelProfileProvider, ModelProfileProvider
 from klaude_code.core.manager import LLMClients, SubAgentManager
-from klaude_code.core.tool import current_run_subtask_callback
 from klaude_code.llm.registry import create_llm_client
+from klaude_code.log import DebugType, log_debug
 from klaude_code.protocol import commands, events, message, model, op
-from klaude_code.protocol.llm_param import Thinking
+from klaude_code.protocol.llm_param import LLMConfigParameter, Thinking
 from klaude_code.protocol.op_handler import OperationHandler
 from klaude_code.protocol.sub_agent import SubAgentResult
 from klaude_code.session.export import build_export_html, get_default_export_path
 from klaude_code.session.session import Session
-from klaude_code.trace import DebugType, log_debug
 
 
 @dataclass
@@ -80,45 +80,26 @@ class TaskManager:
         self._tasks.clear()
 
 
-class ExecutorContext:
-    """
-    Context object providing shared state and operations for the executor.
-
-    This context is passed to operations when they execute, allowing them
-    to access shared resources like the event queue and active sessions.
-
-    Implements the OperationHandler protocol via structural subtyping.
-    """
+class AgentRuntime:
+    """Coordinate agent lifecycle and in-flight tasks for the executor."""
 
     def __init__(
         self,
-        event_queue: asyncio.Queue[events.Event],
+        *,
+        emit_event: Callable[[events.Event], Awaitable[None]],
         llm_clients: LLMClients,
-        model_profile_provider: ModelProfileProvider | None = None,
-        on_model_change: Callable[[str], None] | None = None,
-    ):
-        self.event_queue: asyncio.Queue[events.Event] = event_queue
-        self.llm_clients: LLMClients = llm_clients
-
-        resolved_profile_provider = model_profile_provider or DefaultModelProfileProvider()
-        self.model_profile_provider: ModelProfileProvider = resolved_profile_provider
-
-        self.task_manager = TaskManager()
-        self.sub_agent_manager = SubAgentManager(event_queue, llm_clients, resolved_profile_provider)
-        self._on_model_change = on_model_change
+        model_profile_provider: ModelProfileProvider,
+        task_manager: TaskManager,
+        sub_agent_manager: SubAgentManager,
+    ) -> None:
+        self._emit_event = emit_event
+        self._llm_clients = llm_clients
+        self._model_profile_provider = model_profile_provider
+        self._task_manager = task_manager
+        self._sub_agent_manager = sub_agent_manager
         self._agent: Agent | None = None
 
-    async def emit_event(self, event: events.Event) -> None:
-        """Emit an event to the UI display system."""
-        await self.event_queue.put(event)
-
     def current_session_id(self) -> str | None:
-        """Return the primary active session id, if any.
-
-        This is a convenience wrapper used by the CLI, which conceptually
-        operates on a single interactive session per process.
-        """
-
         agent = self._agent
         if agent is None:
             return None
@@ -126,19 +107,11 @@ class ExecutorContext:
 
     @property
     def current_agent(self) -> Agent | None:
-        """Return the currently active agent, if any."""
-
         return self._agent
 
-    async def _ensure_agent(self, session_id: str | None = None) -> Agent:
-        """Return the active agent, creating or loading a session as needed.
+    async def ensure_agent(self, session_id: str | None = None) -> Agent:
+        """Return the active agent, creating or loading a session as needed."""
 
-        If ``session_id`` is ``None``, a new session is created with an
-        auto-generated ID. If provided, the executor attempts to resume the
-        session from disk or creates a new one if not found.
-        """
-
-        # Fast-path: reuse current agent when the session id already matches.
         if session_id is not None and self._agent is not None and self._agent.session.id == session_id:
             return self._agent
 
@@ -147,20 +120,21 @@ class ExecutorContext:
         if (
             session.model_thinking is not None
             and session.model_name
-            and session.model_name == self.llm_clients.main.model_name
+            and session.model_name == self._llm_clients.main.model_name
         ):
-            self.llm_clients.main.get_llm_config().thinking = session.model_thinking
+            self._llm_clients.main.get_llm_config().thinking = session.model_thinking
 
-        profile = self.model_profile_provider.build_profile(self.llm_clients.main)
+        profile = self._model_profile_provider.build_profile(self._llm_clients.main)
         agent = Agent(session=session, profile=profile)
 
         async for evt in agent.replay_history():
-            await self.emit_event(evt)
+            await self._emit_event(evt)
 
-        await self.emit_event(
+        await self._emit_event(
             events.WelcomeEvent(
+                session_id=session.id,
                 work_dir=str(session.work_dir),
-                llm_config=self.llm_clients.main.get_llm_config(),
+                llm_config=self._llm_clients.main.get_llm_config(),
             )
         )
 
@@ -172,94 +146,44 @@ class ExecutorContext:
         )
         return agent
 
-    async def handle_init_agent(self, operation: op.InitAgentOperation) -> None:
-        """Initialize an agent for a session and replay history to UI."""
-        await self._ensure_agent(operation.session_id)
+    async def init_agent(self, session_id: str | None) -> None:
+        await self.ensure_agent(session_id)
 
-    async def handle_run_agent(self, operation: op.RunAgentOperation) -> None:
-        agent = await self._ensure_agent(operation.session_id)
-        existing_active = self.task_manager.get(operation.id)
-        if existing_active is not None and not existing_active.task.done():
-            raise RuntimeError(f"Active task already registered for operation {operation.id}")
-        task: asyncio.Task[None] = asyncio.create_task(
-            self._run_agent_task(agent, operation.input, operation.id, operation.session_id)
-        )
-        self.task_manager.register(operation.id, task, operation.session_id)
-
-    async def handle_change_model(self, operation: op.ChangeModelOperation) -> None:
-        agent = await self._ensure_agent(operation.session_id)
-        config = load_config()
-
-        llm_config = config.get_model_config(operation.model_name)
-        llm_client = create_llm_client(llm_config)
-        agent.set_model_profile(self.model_profile_provider.build_profile(llm_client))
-
-        agent.session.model_config_name = operation.model_name
-        agent.session.model_thinking = llm_config.thinking
-
-        if operation.save_as_default:
-            config.main_model = operation.model_name
-            await config.save()
+    async def run_agent(self, operation: op.RunAgentOperation) -> None:
+        agent = await self.ensure_agent(operation.session_id)
 
-        if operation.emit_switch_message:
-            default_note = " (saved as default)" if operation.save_as_default else ""
-            developer_item = message.DeveloperMessage(
-                parts=message.text_parts_from_str(f"Switched to: {llm_config.model}{default_note}"),
-                command_output=model.CommandOutput(command_name=commands.CommandName.MODEL),
+        if operation.emit_user_message_event:
+            await self._emit_event(
+                events.UserMessageEvent(
+                    content=operation.input.text,
+                    session_id=agent.session.id,
+                    images=operation.input.images,
+                )
             )
-            agent.session.append_history([developer_item])
-            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
-
-        if self._on_model_change is not None:
-            self._on_model_change(llm_client.model_name)
-
-        if operation.emit_welcome_event:
-            await self.emit_event(events.WelcomeEvent(llm_config=llm_config, work_dir=str(agent.session.work_dir)))
-
-    async def handle_change_thinking(self, operation: op.ChangeThinkingOperation) -> None:
-        """Handle a change thinking operation.
-
-        Interactive thinking selection must happen in the UI/CLI layer. Core only
-        applies a concrete thinking configuration.
-        """
-        agent = await self._ensure_agent(operation.session_id)
-
-        config = agent.profile.llm_client.get_llm_config()
-
-        def _format_thinking_for_display(thinking: Thinking | None) -> str:
-            if thinking is None:
-                return "not configured"
-            if thinking.reasoning_effort:
-                return f"reasoning_effort={thinking.reasoning_effort}"
-            if thinking.type == "disabled":
-                return "off"
-            if thinking.type == "enabled":
-                if thinking.budget_tokens is None:
-                    return "enabled"
-                return f"enabled (budget_tokens={thinking.budget_tokens})"
-            return "not set"
-
-        if operation.thinking is None:
-            raise ValueError("thinking must be provided; interactive selection belongs to UI")
-
-        current = _format_thinking_for_display(config.thinking)
-        config.thinking = operation.thinking
-        agent.session.model_thinking = operation.thinking
-        new_status = _format_thinking_for_display(config.thinking)
 
-        if operation.emit_switch_message:
-            developer_item = message.DeveloperMessage(
-                parts=message.text_parts_from_str(f"Thinking changed: {current} -> {new_status}"),
-                command_output=model.CommandOutput(command_name=commands.CommandName.THINKING),
+        if operation.persist_user_input:
+            agent.session.append_history(
+                [
+                    message.UserMessage(
+                        parts=message.parts_from_text_and_images(
+                            operation.input.text,
+                            operation.input.images,
+                        )
+                    )
+                ]
             )
-            agent.session.append_history([developer_item])
-            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
 
-        if operation.emit_welcome_event:
-            await self.emit_event(events.WelcomeEvent(work_dir=str(agent.session.work_dir), llm_config=config))
+        existing_active = self._task_manager.get(operation.id)
+        if existing_active is not None and not existing_active.task.done():
+            raise RuntimeError(f"Active task already registered for operation {operation.id}")
 
-    async def handle_clear_session(self, operation: op.ClearSessionOperation) -> None:
-        agent = await self._ensure_agent(operation.session_id)
+        task: asyncio.Task[None] = asyncio.create_task(
+            self._run_agent_task(agent, operation.input, operation.id, operation.session_id)
+        )
+        self._task_manager.register(operation.id, task, operation.session_id)
+
+    async def clear_session(self, session_id: str) -> None:
+        agent = await self.ensure_agent(session_id)
         new_session = Session.create(work_dir=agent.session.work_dir)
         new_session.model_name = agent.session.model_name
         new_session.model_config_name = agent.session.model_config_name
@@ -268,37 +192,37 @@ class ExecutorContext:
 
         developer_item = message.DeveloperMessage(
             parts=message.text_parts_from_str("started new conversation"),
-            command_output=model.CommandOutput(command_name=commands.CommandName.CLEAR),
+            ui_extra=model.build_command_output_extra(commands.CommandName.CLEAR),
         )
-        await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
-        await self.emit_event(
+        await self._emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+        await self._emit_event(
             events.WelcomeEvent(
+                session_id=agent.session.id,
                 work_dir=str(agent.session.work_dir),
-                llm_config=self.llm_clients.main.get_llm_config(),
+                llm_config=self._llm_clients.main.get_llm_config(),
             )
         )
 
-    async def handle_resume_session(self, operation: op.ResumeSessionOperation) -> None:
-        target_session = Session.load(operation.target_session_id)
+    async def resume_session(self, target_session_id: str) -> None:
+        target_session = Session.load(target_session_id)
         if (
             target_session.model_thinking is not None
             and target_session.model_name
-            and target_session.model_name == self.llm_clients.main.model_name
+            and target_session.model_name == self._llm_clients.main.model_name
         ):
-            self.llm_clients.main.get_llm_config().thinking = target_session.model_thinking
-
-        profile = self.model_profile_provider.build_profile(self.llm_clients.main)
-        from klaude_code.core.agent import Agent
+            self._llm_clients.main.get_llm_config().thinking = target_session.model_thinking
 
+        profile = self._model_profile_provider.build_profile(self._llm_clients.main)
         agent = Agent(session=target_session, profile=profile)
 
         async for evt in agent.replay_history():
-            await self.emit_event(evt)
+            await self._emit_event(evt)
 
-        await self.emit_event(
+        await self._emit_event(
             events.WelcomeEvent(
+                session_id=target_session.id,
                 work_dir=str(target_session.work_dir),
-                llm_config=self.llm_clients.main.get_llm_config(),
+                llm_config=self._llm_clients.main.get_llm_config(),
             )
         )
 
@@ -309,29 +233,38 @@ class ExecutorContext:
             debug_type=DebugType.EXECUTION,
         )
 
-    async def handle_export_session(self, operation: op.ExportSessionOperation) -> None:
-        agent = await self._ensure_agent(operation.session_id)
-        try:
-            output_path = self._resolve_export_output_path(operation.output_path, agent.session)
-            html_doc = self._build_export_html(agent)
-            await asyncio.to_thread(output_path.parent.mkdir, parents=True, exist_ok=True)
-            await asyncio.to_thread(output_path.write_text, html_doc, "utf-8")
-            await asyncio.to_thread(self._open_file, output_path)
-            developer_item = message.DeveloperMessage(
-                parts=message.text_parts_from_str(f"Session exported and opened: {output_path}"),
-                command_output=model.CommandOutput(command_name=commands.CommandName.EXPORT),
-            )
-            agent.session.append_history([developer_item])
-            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
-        except Exception as exc:  # pragma: no cover
-            import traceback
+    async def interrupt(self, target_session_id: str | None) -> None:
+        if target_session_id is not None:
+            session_ids: list[str] = [target_session_id]
+        else:
+            agent = self._agent
+            session_ids = [agent.session.id] if agent is not None else []
 
-            developer_item = message.DeveloperMessage(
-                parts=message.text_parts_from_str(f"Failed to export session: {exc}\n{traceback.format_exc()}"),
-                command_output=model.CommandOutput(command_name=commands.CommandName.EXPORT, is_error=True),
-            )
-            agent.session.append_history([developer_item])
-            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+        for sid in session_ids:
+            agent = self._get_active_agent(sid)
+            if agent is not None:
+                for evt in agent.cancel():
+                    await self._emit_event(evt)
+
+        await self._emit_event(events.InterruptEvent(session_id=target_session_id or "all"))
+
+        if target_session_id is None:
+            session_filter: set[str] | None = None
+        else:
+            session_filter = {target_session_id}
+
+        tasks_to_cancel = self._task_manager.cancel_tasks_for_sessions(session_filter)
+
+        scope = target_session_id or "all"
+        log_debug(
+            f"Interrupting {len(tasks_to_cancel)} task(s) for: {scope}",
+            style="yellow",
+            debug_type=DebugType.EXECUTION,
+        )
+
+        for task_id, task in tasks_to_cancel:
+            task.cancel()
+            self._task_manager.remove(task_id)
 
     async def _run_agent_task(
         self,
@@ -347,15 +280,14 @@ class ExecutorContext:
                 debug_type=DebugType.EXECUTION,
             )
 
-            async def _runner(state: model.SubAgentState) -> SubAgentResult:
-                return await self.sub_agent_manager.run_sub_agent(agent, state)
+            async def _runner(
+                state: model.SubAgentState,
+                record_session_id: Callable[[str], None] | None,
+            ) -> SubAgentResult:
+                return await self._sub_agent_manager.run_sub_agent(agent, state, record_session_id=record_session_id)
 
-            token = current_run_subtask_callback.set(_runner)
-            try:
-                async for event in agent.run_task(user_input):
-                    await self.emit_event(event)
-            finally:
-                current_run_subtask_callback.reset(token)
+            async for event in agent.run_task(user_input, run_subtask=_runner):
+                await self._emit_event(event)
 
         except asyncio.CancelledError:
             log_debug(
@@ -363,7 +295,7 @@ class ExecutorContext:
                 style="yellow",
                 debug_type=DebugType.EXECUTION,
             )
-            await self.emit_event(events.TaskFinishEvent(session_id=session_id, task_result="task cancelled"))
+            await self._emit_event(events.TaskFinishEvent(session_id=session_id, task_result="task cancelled"))
 
         except Exception as e:
             import traceback
@@ -374,20 +306,234 @@ class ExecutorContext:
                 debug_type=DebugType.EXECUTION,
             )
             log_debug(traceback.format_exc(), style="red", debug_type=DebugType.EXECUTION)
-            await self.emit_event(
+            await self._emit_event(
                 events.ErrorEvent(
                     error_message=f"Agent task failed: [{e.__class__.__name__}] {e!s} {traceback.format_exc()}",
                     can_retry=False,
+                    session_id=session_id,
                 )
             )
         finally:
-            self.task_manager.remove(task_id)
+            self._task_manager.remove(task_id)
             log_debug(
                 f"Cleaned up agent task {task_id}",
                 style="cyan",
                 debug_type=DebugType.EXECUTION,
             )
 
+    def _get_active_agent(self, session_id: str) -> Agent | None:
+        agent = self._agent
+        if agent is None:
+            return None
+        if agent.session.id != session_id:
+            return None
+        return agent
+
+
+class ModelSwitcher:
+    """Apply model changes to an agent session."""
+
+    def __init__(self, model_profile_provider: ModelProfileProvider) -> None:
+        self._model_profile_provider = model_profile_provider
+
+    async def change_model(
+        self,
+        agent: Agent,
+        *,
+        model_name: str,
+        save_as_default: bool,
+    ) -> tuple[LLMConfigParameter, str]:
+        config = load_config()
+        llm_config = config.get_model_config(model_name)
+        llm_client = create_llm_client(llm_config)
+        agent.set_model_profile(self._model_profile_provider.build_profile(llm_client))
+
+        agent.session.model_config_name = model_name
+        agent.session.model_thinking = llm_config.thinking
+
+        if save_as_default:
+            config.main_model = model_name
+            await config.save()
+
+        return llm_config, llm_client.model_name
+
+    def change_thinking(self, agent: Agent, *, thinking: Thinking) -> Thinking | None:
+        """Apply thinking configuration to the agent's active LLM config and persisted session."""
+
+        config = agent.profile.llm_client.get_llm_config()
+        previous = config.thinking
+        config.thinking = thinking
+        agent.session.model_thinking = thinking
+        return previous
+
+
+class ExecutorContext:
+    """
+    Context object providing shared state and operations for the executor.
+
+    This context is passed to operations when they execute, allowing them
+    to access shared resources like the event queue and active sessions.
+
+    Implements the OperationHandler protocol via structural subtyping.
+    """
+
+    def __init__(
+        self,
+        event_queue: asyncio.Queue[events.Event],
+        llm_clients: LLMClients,
+        model_profile_provider: ModelProfileProvider | None = None,
+        on_model_change: Callable[[str], None] | None = None,
+    ):
+        self.event_queue: asyncio.Queue[events.Event] = event_queue
+        self.llm_clients: LLMClients = llm_clients
+
+        resolved_profile_provider = model_profile_provider or DefaultModelProfileProvider()
+        self.model_profile_provider: ModelProfileProvider = resolved_profile_provider
+
+        self.task_manager = TaskManager()
+        self.sub_agent_manager = SubAgentManager(event_queue, llm_clients, resolved_profile_provider)
+        self._on_model_change = on_model_change
+        self._agent_runtime = AgentRuntime(
+            emit_event=self.emit_event,
+            llm_clients=llm_clients,
+            model_profile_provider=resolved_profile_provider,
+            task_manager=self.task_manager,
+            sub_agent_manager=self.sub_agent_manager,
+        )
+        self._model_switcher = ModelSwitcher(resolved_profile_provider)
+
+    async def emit_event(self, event: events.Event) -> None:
+        """Emit an event to the UI display system."""
+        await self.event_queue.put(event)
+
+    def current_session_id(self) -> str | None:
+        """Return the primary active session id, if any.
+
+        This is a convenience wrapper used by the CLI, which conceptually
+        operates on a single interactive session per process.
+        """
+
+        return self._agent_runtime.current_session_id()
+
+    @property
+    def current_agent(self) -> Agent | None:
+        """Return the currently active agent, if any."""
+
+        return self._agent_runtime.current_agent
+
+    async def handle_init_agent(self, operation: op.InitAgentOperation) -> None:
+        """Initialize an agent for a session and replay history to UI."""
+        await self._agent_runtime.init_agent(operation.session_id)
+
+    async def handle_run_agent(self, operation: op.RunAgentOperation) -> None:
+        await self._agent_runtime.run_agent(operation)
+
+    async def handle_change_model(self, operation: op.ChangeModelOperation) -> None:
+        agent = await self._agent_runtime.ensure_agent(operation.session_id)
+        llm_config, llm_client_name = await self._model_switcher.change_model(
+            agent,
+            model_name=operation.model_name,
+            save_as_default=operation.save_as_default,
+        )
+
+        if operation.emit_switch_message:
+            default_note = " (saved as default)" if operation.save_as_default else ""
+            developer_item = message.DeveloperMessage(
+                parts=message.text_parts_from_str(f"Switched to: {llm_config.model}{default_note}"),
+                ui_extra=model.build_command_output_extra(commands.CommandName.MODEL),
+            )
+            agent.session.append_history([developer_item])
+            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+
+        if self._on_model_change is not None:
+            self._on_model_change(llm_client_name)
+
+        if operation.emit_welcome_event:
+            await self.emit_event(
+                events.WelcomeEvent(
+                    session_id=agent.session.id,
+                    llm_config=llm_config,
+                    work_dir=str(agent.session.work_dir),
+                    show_klaude_code_info=False,
+                )
+            )
+
+    async def handle_change_thinking(self, operation: op.ChangeThinkingOperation) -> None:
+        """Handle a change thinking operation.
+
+        Interactive thinking selection must happen in the UI/CLI layer. Core only
+        applies a concrete thinking configuration.
+        """
+        agent = await self._agent_runtime.ensure_agent(operation.session_id)
+
+        def _format_thinking_for_display(thinking: Thinking | None) -> str:
+            if thinking is None:
+                return "not configured"
+            if thinking.reasoning_effort:
+                return f"reasoning_effort={thinking.reasoning_effort}"
+            if thinking.type == "disabled":
+                return "off"
+            if thinking.type == "enabled":
+                if thinking.budget_tokens is None:
+                    return "enabled"
+                return f"enabled (budget_tokens={thinking.budget_tokens})"
+            return "not set"
+
+        if operation.thinking is None:
+            raise ValueError("thinking must be provided; interactive selection belongs to UI")
+
+        previous = self._model_switcher.change_thinking(agent, thinking=operation.thinking)
+        current = _format_thinking_for_display(previous)
+        new_status = _format_thinking_for_display(operation.thinking)
+
+        if operation.emit_switch_message:
+            developer_item = message.DeveloperMessage(
+                parts=message.text_parts_from_str(f"Thinking changed: {current} -> {new_status}"),
+                ui_extra=model.build_command_output_extra(commands.CommandName.THINKING),
+            )
+            agent.session.append_history([developer_item])
+            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+
+        if operation.emit_welcome_event:
+            await self.emit_event(
+                events.WelcomeEvent(
+                    session_id=agent.session.id,
+                    work_dir=str(agent.session.work_dir),
+                    llm_config=agent.profile.llm_client.get_llm_config(),
+                    show_klaude_code_info=False,
+                )
+            )
+
+    async def handle_clear_session(self, operation: op.ClearSessionOperation) -> None:
+        await self._agent_runtime.clear_session(operation.session_id)
+
+    async def handle_resume_session(self, operation: op.ResumeSessionOperation) -> None:
+        await self._agent_runtime.resume_session(operation.target_session_id)
+
+    async def handle_export_session(self, operation: op.ExportSessionOperation) -> None:
+        agent = await self._agent_runtime.ensure_agent(operation.session_id)
+        try:
+            output_path = self._resolve_export_output_path(operation.output_path, agent.session)
+            html_doc = self._build_export_html(agent)
+            await asyncio.to_thread(output_path.parent.mkdir, parents=True, exist_ok=True)
+            await asyncio.to_thread(output_path.write_text, html_doc, "utf-8")
+            await asyncio.to_thread(self._open_file, output_path)
+            developer_item = message.DeveloperMessage(
+                parts=message.text_parts_from_str(f"Session exported and opened: {output_path}"),
+                ui_extra=model.build_command_output_extra(commands.CommandName.EXPORT),
+            )
+            agent.session.append_history([developer_item])
+            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+        except Exception as exc:  # pragma: no cover
+            import traceback
+
+            developer_item = message.DeveloperMessage(
+                parts=message.text_parts_from_str(f"Failed to export session: {exc}\n{traceback.format_exc()}"),
+                ui_extra=model.build_command_output_extra(commands.CommandName.EXPORT, is_error=True),
+            )
+            agent.session.append_history([developer_item])
+            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+
     def _resolve_export_output_path(self, raw: str | None, session: Session) -> Path:
         trimmed = (raw or "").strip()
         if trimmed:
@@ -432,43 +578,7 @@ class ExecutorContext:
     async def handle_interrupt(self, operation: op.InterruptOperation) -> None:
         """Handle an interrupt by invoking agent.cancel() and cancelling tasks."""
 
-        # Determine affected sessions
-        if operation.target_session_id is not None:
-            session_ids: list[str] = [operation.target_session_id]
-        else:
-            agent = self._agent
-            session_ids = [agent.session.id] if agent is not None else []
-
-        # Call cancel() on each affected agent to persist an interrupt marker
-        for sid in session_ids:
-            agent = self._get_active_agent(sid)
-            if agent is not None:
-                for evt in agent.cancel():
-                    await self.emit_event(evt)
-
-        # emit interrupt event
-        await self.emit_event(events.InterruptEvent(session_id=operation.target_session_id or "all"))
-
-        # Find tasks to cancel (filter by target sessions if provided)
-        if operation.target_session_id is None:
-            session_filter: set[str] | None = None
-        else:
-            session_filter = {operation.target_session_id}
-
-        tasks_to_cancel = self.task_manager.cancel_tasks_for_sessions(session_filter)
-
-        scope = operation.target_session_id or "all"
-        log_debug(
-            f"Interrupting {len(tasks_to_cancel)} task(s) for: {scope}",
-            style="yellow",
-            debug_type=DebugType.EXECUTION,
-        )
-
-        # Cancel the tasks
-        for task_id, task in tasks_to_cancel:
-            task.cancel()
-            # Remove from active tasks immediately
-            self.task_manager.remove(task_id)
+        await self._agent_runtime.interrupt(operation.target_session_id)
 
     def get_active_task(self, submission_id: str) -> asyncio.Task[None] | None:
         """Return the asyncio.Task for a submission id if one is registered."""
@@ -483,16 +593,6 @@ class ExecutorContext:
 
         return self.task_manager.get(submission_id) is not None
 
-    def _get_active_agent(self, session_id: str) -> Agent | None:
-        """Return the active agent if its session id matches ``session_id``."""
-
-        agent = self._agent
-        if agent is None:
-            return None
-        if agent.session.id != session_id:
-            return None
-        return agent
-
 
 class Executor:
     """
@@ -590,7 +690,11 @@ class Executor:
                     debug_type=DebugType.EXECUTION,
                 )
                 await self.context.emit_event(
-                    events.ErrorEvent(error_message=f"Executor error: {e!s}", can_retry=False)
+                    events.ErrorEvent(
+                        error_message=f"Executor error: {e!s}",
+                        can_retry=False,
+                        session_id="__app__",
+                    )
                 )
 
     async def stop(self) -> None:
@@ -667,7 +771,16 @@ class Executor:
                 style="red",
                 debug_type=DebugType.EXECUTION,
             )
-            await self.context.emit_event(events.ErrorEvent(error_message=f"Operation failed: {e!s}", can_retry=False))
+            session_id = getattr(submission.operation, "session_id", None) or getattr(
+                submission.operation, "target_session_id", None
+            )
+            await self.context.emit_event(
+                events.ErrorEvent(
+                    error_message=f"Operation failed: {e!s}",
+                    can_retry=False,
+                    session_id=session_id or "__app__",
+                )
+            )
             # Set completion event even on error to prevent wait_for_completion from hanging
             event = self._completion_events.get(submission.id)
             if event is not None: