klaude-code 2.34.0__tar.gz → 2.35.0__tar.gz

{klaude_code-2.34.0 → klaude_code-2.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 2.34.0
+Version: 2.35.0
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic[bedrock]>=1.8.0,<2
 Requires-Dist: chardet>=5.2.0,<6

{klaude_code-2.34.0 → klaude_code-2.35.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "2.34.0"
+version = "2.35.0"
 description = "Minimal code agent CLI"
 readme = "README.md"
 requires-python = ">=3.13"

{klaude_code-2.34.0 → klaude_code-2.35.0}/src/klaude_code/agent/agent.py

@@ -12,6 +12,7 @@ from klaude_code.protocol.models import TaskMetadata
 from klaude_code.session import Session
 from klaude_code.tool import build_todo_context, get_registry
 from klaude_code.tool.core.context import RunSubtask
+from klaude_code.tool.shell.task_manager import ShellTaskManager
 
 
 class Agent:
@@ -33,6 +34,7 @@ class Agent:
             | None
         ) = None,
         model_profile_provider: ModelProfileProvider | None = None,
+        shell_task_manager: ShellTaskManager | None = None,
     ):
         self.session: Session = session
         self.profile: AgentProfile = profile
@@ -47,6 +49,7 @@ class Agent:
         self._last_interrupt_prefill_text: str | None = None
         self.request_user_interaction = request_user_interaction
         self._model_profile_provider = model_profile_provider
+        self.shell_task_manager = shell_task_manager
         if not self.session.model_name:
             self.session.model_name = profile.llm_client.model_name
 
@@ -195,6 +198,7 @@ class Agent:
             run_subtask=run_subtask,
             request_user_interaction=self.request_user_interaction,
             prompt_cache_key=self.session.prompt_cache_key,
+            shell_task_manager=self.shell_task_manager,
         )
         context = TaskExecutionContext(
             session=self.session,

{klaude_code-2.34.0 → klaude_code-2.35.0}/src/klaude_code/agent/agent_profile.py

@@ -38,7 +38,7 @@ class AgentProfile:
     attachments: list[Attachment]
 
 
-MAIN_AGENT_COMMON_BASE_TOOLS: list[str] = [tools.BASH, tools.READ]
+MAIN_AGENT_COMMON_BASE_TOOLS: list[str] = [tools.BASH, tools.MANAGE_SHELL, tools.READ]
 MAIN_AGENT_APPLY_PATCH_DIFF_TOOLS: list[str] = [tools.APPLY_PATCH, tools.TODO_WRITE]
 MAIN_AGENT_EDIT_WRITE_DIFF_TOOLS: list[str] = [tools.EDIT, tools.WRITE, tools.TODO_WRITE]
 MAIN_AGENT_COMMON_TOOLS: list[str] = [
@@ -219,6 +219,6 @@ class VanillaModelProfileProvider(ModelProfileProvider):
         return AgentProfile(
             llm_client=llm_client,
             system_prompt="You're an agent running in user's terminal",
-            tools=get_tool_schemas([tools.BASH, tools.EDIT, tools.WRITE, tools.READ]),
+            tools=get_tool_schemas([tools.BASH, tools.MANAGE_SHELL, tools.EDIT, tools.WRITE, tools.READ]),
             attachments=[],
         )

{klaude_code-2.34.0 → klaude_code-2.35.0}/src/klaude_code/agent/runtime/agent_ops.py

@@ -46,6 +46,7 @@ from klaude_code.protocol import events, message, op, user_interaction
 from klaude_code.protocol.models import SubAgentState, TaskMetadata
 from klaude_code.protocol.sub_agent import SubAgentResult
 from klaude_code.session.session import Session
+from klaude_code.tool.shell.task_manager import ShellTaskManager
 from klaude_code.update import get_startup_update_summary
 
 
@@ -100,8 +101,12 @@ class AgentOperationHandler:
             [PendingUserInteractionRequest],
             Awaitable[user_interaction.UserInteractionResponse],
         ],
+        shell_task_manager: ShellTaskManager | None = None,
+        has_pending_shell_notifications: Callable[[str], bool] | None = None,
     ) -> None:
         self._emit_event = emit_event
+        self._shell_task_manager = shell_task_manager
+        self._has_pending_shell_notifications = has_pending_shell_notifications
         self._llm_clients_template = llm_clients
         self._model_profile_provider = model_profile_provider
         self._sub_agent_launcher: SubAgentLauncher | None = None
@@ -401,6 +406,7 @@ class AgentOperationHandler:
             compact_llm_client=session_clients.compact,
             request_user_interaction=self._build_request_user_interaction_callback(session_id=session.id),
             model_profile_provider=profile_provider,
+            shell_task_manager=self._shell_task_manager,
         )
 
         # Another initializer may have completed while this one built the
@@ -498,6 +504,7 @@ class AgentOperationHandler:
             compact_llm_client=session_clients.compact,
             request_user_interaction=self._build_request_user_interaction_callback(session_id=session.id),
             model_profile_provider=profile_provider,
+            shell_task_manager=self._shell_task_manager,
         )
         runtime.set_agent(agent)
         return agent
@@ -639,6 +646,10 @@ class AgentOperationHandler:
                 debug_type=DebugType.EXECUTION,
             )
             return
+        if (self._shell_task_manager is not None and session_id in self._shell_task_manager.active_session_ids()) or (
+            self._has_pending_shell_notifications is not None and self._has_pending_shell_notifications(session_id)
+        ):
+            return
         suppress = should_suggest(agent.session)
         if suppress is not None:
             log_debug(
@@ -720,10 +731,7 @@ class AgentOperationHandler:
         frozen_images = await asyncio.to_thread(
             lambda: [freeze_image_for_history(image, images_dir=images_dir) for image in images]
         )
-        return message.UserInputPayload(
-            text=user_input.text,
-            images=frozen_images,
-        )
+        return user_input.model_copy(update={"images": frozen_images})
 
     async def run_agent(self, operation: op.RunAgentOperation) -> None:
         agent = await self.ensure_agent(operation.session_id)
@@ -749,10 +757,14 @@ class AgentOperationHandler:
                             frozen_input.text,
                             frozen_input.images,
                         ),
+                        source=frozen_input.source,
+                        shell_tasks=frozen_input.shell_tasks,
                     )
                 ]
             )
-        if self._should_refresh_session_title_during_task(agent.session.id):
+        if operation.shell_notification_generation is None and self._should_refresh_session_title_during_task(
+            agent.session.id
+        ):
             self._schedule_session_title_refresh(agent.session)
 
         existing_active = self.get_active_task(operation.id)
@@ -763,7 +775,13 @@ class AgentOperationHandler:
 
         async def _run_with_event_context() -> None:
             with event_publish_context(task_id=task_id):
-                await self._run_agent_task(agent, frozen_input, task_id, operation.session_id)
+                await self._run_agent_task(
+                    agent,
+                    frozen_input,
+                    task_id,
+                    operation.session_id,
+                    shell_notification=operation.shell_notification_generation is not None,
+                )
 
         task: asyncio.Task[None] = asyncio.create_task(_run_with_event_context())
         self._register_task(
@@ -1098,6 +1116,7 @@ class AgentOperationHandler:
             compact_llm_client=session_clients.compact,
             request_user_interaction=self._build_request_user_interaction_callback(session_id=new_session.id),
             model_profile_provider=self._model_profile_provider,
+            shell_task_manager=self._shell_task_manager,
         )
 
         old_runtime.clear_execution_state()
@@ -1146,6 +1165,7 @@ class AgentOperationHandler:
             compact_llm_client=session_clients.compact,
             request_user_interaction=self._build_request_user_interaction_callback(session_id=new_session.id),
             model_profile_provider=self._model_profile_provider,
+            shell_task_manager=self._shell_task_manager,
         )
 
         old_runtime.clear_execution_state()
@@ -1435,6 +1455,8 @@ class AgentOperationHandler:
         user_input: message.UserInputPayload,
         task_id: str,
         session_id: str,
+        *,
+        shell_notification: bool = False,
     ) -> None:
         try:
             log_debug(
@@ -1471,7 +1493,8 @@ class AgentOperationHandler:
 
             # Task completed normally — predict the user's next prompt in the
             # background. Cancelled implicitly when the next user turn starts.
-            self._schedule_prompt_suggestion(agent)
+            if not shell_notification:
+                self._schedule_prompt_suggestion(agent)
 
         except asyncio.CancelledError:
             log_debug(
@@ -1495,7 +1518,7 @@ class AgentOperationHandler:
             )
         finally:
             self._remove_task(session_id=session_id, task_id=task_id)
-            if not self._should_refresh_session_title_during_task(session_id):
+            if not shell_notification and not self._should_refresh_session_title_during_task(session_id):
                 self._schedule_session_title_refresh(agent.session)
             log_debug(
                 f"Cleaned up agent task {task_id}",

{klaude_code-2.34.0 → klaude_code-2.35.0}/src/klaude_code/agent/runtime/dispatcher.py

@@ -3,8 +3,10 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
+from pathlib import Path
 from typing import Literal
 
 from klaude_code.agent.agent import Agent
@@ -18,6 +20,7 @@ from klaude_code.control.runtime.actor import SessionActor
 from klaude_code.control.user_interaction import PendingUserInteractionRequest
 from klaude_code.protocol import events, op, user_interaction
 from klaude_code.protocol.op_handler import OperationHandler
+from klaude_code.tool.shell.task_manager import ShellTaskManager
 
 
 @dataclass(frozen=True)
@@ -40,6 +43,7 @@ class OperationDispatcherPorts:
     # and awaits operations on them via these facade entry points.
     submit_operation: Callable[[op.Operation], Awaitable[str]]
     wait_for_operation: Callable[[str], Awaitable[Literal["completed", "rejected", "failed"] | None]]
+    disable_shell_notifications: Callable[[str], None]
 
 
 class OperationDispatcher:
@@ -59,10 +63,13 @@ class OperationDispatcher:
         ports: OperationDispatcherPorts,
         model_profile_provider: ModelProfileProvider | None = None,
         on_model_change: Callable[[str], None] | None = None,
+        shell_task_manager: ShellTaskManager | None = None,
+        has_pending_shell_notifications: Callable[[str], bool] | None = None,
     ):
         self._event_bus = event_bus
         self.llm_clients: LLMClients = llm_clients
         self._ports = ports
+        self._shell_task_manager = shell_task_manager
 
         resolved_profile_provider = model_profile_provider or DefaultModelProfileProvider()
         self.model_profile_provider: ModelProfileProvider = resolved_profile_provider
@@ -79,6 +86,8 @@ class OperationDispatcher:
             register_task=ports.register_task,
             remove_task=ports.remove_task,
             request_user_interaction=self.request_user_interaction,
+            shell_task_manager=shell_task_manager,
+            has_pending_shell_notifications=has_pending_shell_notifications,
         )
         self._sub_agent_launcher = SubAgentLauncher(
             handler=self._agent_operation_handler,
@@ -216,6 +225,51 @@ class OperationDispatcher:
     async def handle_run_bash(self, operation: op.RunBashOperation) -> None:
         await self._agent_operation_handler.run_bash(operation)
 
+    async def handle_manage_shell(self, operation: op.ManageShellOperation) -> None:
+        manager = self._shell_task_manager
+        if manager is None:
+            return
+        actor = self._ports.get_session_actor(operation.session_id)
+        agent = actor.get_agent() if actor is not None else None
+        work_dir = agent.session.work_dir if agent is not None else None
+        try:
+            tasks = await manager.list_tasks(operation.session_id, work_dir=work_dir)
+            if operation.action == "list":
+                await self.emit_event(events.ShellTasksUpdatedEvent(session_id=operation.session_id, tasks=tasks))
+                content = (
+                    "\n".join(
+                        f"{task.task_id}  {task.status}  exit={task.exit_code}  {task.description or task.command}"
+                        for task in tasks
+                    )
+                    or "No background shell tasks."
+                )
+            else:
+                task_id = operation.task_id
+                if task_id is None:
+                    if not tasks:
+                        raise ValueError("No background shell tasks.")
+                    task_id = tasks[-1].task_id
+                if operation.action == "stop":
+                    task = await manager.stop_task(operation.session_id, task_id)
+                    content = f"{task.task_id}: {task.status}; log: {task.output_path}"
+                else:
+                    offset = operation.offset
+                    if operation.task_id is None and offset == 0:
+                        task = next(task for task in tasks if task.task_id == task_id)
+                        with contextlib.suppress(OSError):
+                            offset = max(0, Path(task.output_path).stat().st_size - operation.limit)
+                    output = await manager.read_output(
+                        operation.session_id, task_id, offset=offset, limit=operation.limit
+                    )
+                    content = (
+                        f"{output.task.task_id}: {output.task.status}; log: {output.task.output_path}\n"
+                        f"{output.output}\nNext offset: {output.next_offset}"
+                    )
+        except (ValueError, KeyError, OSError) as exc:
+            await self.emit_event(events.NoticeEvent(session_id=operation.session_id, content=str(exc), is_error=True))
+            return
+        await self.emit_event(events.NoticeEvent(session_id=operation.session_id, content=content))
+
     async def handle_continue_agent(self, operation: op.ContinueAgentOperation) -> None:
         await self._agent_operation_handler.continue_agent(operation)
 
@@ -282,6 +336,7 @@ class OperationDispatcher:
         )
         if not interrupted:
             return
+        self._ports.disable_shell_notifications(operation.session_id)
         cancelled_requests = self.cancel_pending_user_interactions(session_id=operation.session_id)
         await self._emit_interaction_cancelled_events(cancelled_requests, reason="interrupt")
         # Sub-agents run in their own actors; cancelling the parent task no

{klaude_code-2.34.0 → klaude_code-2.35.0}/src/klaude_code/agent/step.py

@@ -468,6 +468,7 @@ class StepExecutor:
             run_subtask=session_ctx.run_subtask,
             handoff_manager=ctx.handoff_manager,
             request_user_interaction=session_ctx.request_user_interaction,
+            shell_task_manager=session_ctx.shell_task_manager,
         )
 
         executor = ToolExecutor(

{klaude_code-2.34.0 → klaude_code-2.35.0}/src/klaude_code/agent/task.py

@@ -49,6 +49,7 @@ from klaude_code.protocol.models import (
 from klaude_code.session.session import Session
 from klaude_code.tool import FileTracker, TodoContext, ToolABC, get_registry
 from klaude_code.tool.core.context import RunSubtask
+from klaude_code.tool.shell.task_manager import ShellTaskManager
 
 type RequestUserInteraction = Callable[
     [
@@ -225,6 +226,7 @@ class SessionContext:
     run_subtask: RunSubtask | None
     request_user_interaction: RequestUserInteraction | None
     prompt_cache_key: str | None = None
+    shell_task_manager: ShellTaskManager | None = None
 
 
 @dataclass
@@ -295,6 +297,18 @@ class TaskExecutor:
     ) -> list[events.DeveloperMessageEvent]:
         ctx = self._context
         attachment_results = await collect_attachments(ctx.session, ctx.profile.attachments)
+        manager = ctx.session_ctx.shell_task_manager
+        if manager is not None:
+            tasks = await manager.list_tasks(ctx.session.id, work_dir=ctx.session.work_dir)
+            active = [task for task in tasks if task.status in ("running", "stopping")]
+            if active:
+                # Runtime-owned identifiers only; command/log text is untrusted.
+                summary = "\n".join(f"- {task.task_id}: {task.status}; log: {task.output_path}" for task in active)
+                attachment_results.append(
+                    message.DeveloperMessage(
+                        parts=[message.TextPart(text=f"Active background shell tasks in this session:\n{summary}")]
+                    )
+                )
         events_to_emit: list[events.DeveloperMessageEvent] = []
         existing: set[str] = set()
         if skip_existing:
@@ -620,7 +634,7 @@ class TaskExecutor:
         ctx = self._context
         session_ctx = ctx.session_ctx
         self._started_at = time.perf_counter()
-        self._current_user_input_text = user_input.text
+        self._current_user_input_text = user_input.text if user_input.source != "shell_completion" else None
         self._task_visible_output_started = False
         self._last_interrupt_show_notice = True
         self._last_interrupt_prefill_text = None

{klaude_code-2.34.0 → klaude_code-2.35.0}/src/klaude_code/app/runtime_facade.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import contextlib
-from collections.abc import Callable
+from collections.abc import Awaitable, Callable
 from typing import Literal
 
 from klaude_code.agent.agent import Agent
@@ -14,7 +14,9 @@ from klaude_code.control.runtime.registry import OperationLifecycleHooks, Sessio
 from klaude_code.control.user_interaction import PendingUserInteractionRequest
 from klaude_code.log import DebugType, log_debug
 from klaude_code.protocol import events, op, user_interaction
+from klaude_code.protocol.shell_task import ShellTaskSnapshot
 from klaude_code.session.session import Session
+from klaude_code.tool.shell.task_manager import ShellTaskManager
 
 
 class OperationCompletionAwaiter:
@@ -92,6 +94,14 @@ class RuntimeFacade:
         model_profile_provider: ModelProfileProvider | None = None,
         on_model_change: Callable[[str], None] | None = None,
     ):
+        self._stopped = False
+        self._shell_notification_generations: dict[str, int] = {}
+        self._shell_notifications_disabled: set[str] = set()
+        self._shell_completion_handler: Callable[[ShellTaskSnapshot, int], Awaitable[None]] | None = None
+        self._shell_pending_provider: Callable[[str], bool] | None = None
+        self.shell_task_manager = ShellTaskManager(
+            on_update=self._shell_tasks_updated, on_complete=self._shell_completed
+        )
         self.session_registry = SessionRegistry(
             handle_operation=self._execute_operation,
             reject_operation=self._reject_operation,
@@ -125,9 +135,12 @@ class RuntimeFacade:
                 on_child_task_state_change=self._on_child_task_state_change,
                 submit_operation=self.submit,
                 wait_for_operation=self.wait_for,
+                disable_shell_notifications=self.disable_shell_notifications,
             ),
             model_profile_provider,
             on_model_change,
+            shell_task_manager=self.shell_task_manager,
+            has_pending_shell_notifications=self.has_pending_shell_notifications,
         )
         self._operation_awaiter = OperationCompletionAwaiter(event_bus)
         self._stopped = False
@@ -314,6 +327,30 @@ class RuntimeFacade:
         if self._stopped:
             raise RuntimeError("RuntimeFacade is stopped")
 
+        if isinstance(operation, op.InterruptOperation):
+            actor = self.session_registry.get_session_actor(operation.session_id)
+            root = actor.snapshot().active_root_task if actor is not None else None
+            if operation.expected_operation_id is None or (
+                root is not None and root.operation_id == operation.expected_operation_id
+            ):
+                pending = [operation.session_id]
+                disabled: set[str] = set()
+                actors = self.session_registry.list_session_actors()
+                while pending:
+                    session_id = pending.pop()
+                    if session_id in disabled:
+                        continue
+                    disabled.add(session_id)
+                    self.disable_shell_notifications(session_id)
+                    for actor in actors:
+                        agent = actor.get_agent()
+                        if agent is not None and agent.session.parent_session_id == session_id:
+                            pending.append(actor.session_id)
+        elif (
+            isinstance(operation, op.RunAgentOperation) and operation.shell_notification_generation is None
+        ) or isinstance(operation, op.RunBashOperation | op.FollowUpAgentOperation):
+            self.resume_shell_notifications(operation.session_id)
+
         self._operation_awaiter.register(operation.id)
         try:
             await self.session_registry.submit(operation)
@@ -331,6 +368,39 @@ class RuntimeFacade:
     async def emit_event(self, event: events.Event) -> None:
         await self._operation_dispatcher.emit_event(event)
 
+    async def _shell_tasks_updated(self, session_id: str, tasks: list[ShellTaskSnapshot]) -> None:
+        if not self._stopped:
+            await self.emit_event(events.ShellTasksUpdatedEvent(session_id=session_id, tasks=tasks))
+
+    async def _shell_completed(self, task: ShellTaskSnapshot) -> None:
+        generation = self.shell_notification_generation(task.session_id)
+        if generation is not None and self._shell_completion_handler is not None:
+            await self._shell_completion_handler(task, generation)
+
+    def set_shell_completion_handler(
+        self,
+        handler: Callable[[ShellTaskSnapshot, int], Awaitable[None]] | None,
+        *,
+        has_pending: Callable[[str], bool] | None = None,
+    ) -> None:
+        self._shell_completion_handler = handler
+        self._shell_pending_provider = has_pending
+
+    def has_pending_shell_notifications(self, session_id: str) -> bool:
+        return self._shell_pending_provider is not None and self._shell_pending_provider(session_id)
+
+    def shell_notification_generation(self, session_id: str) -> int | None:
+        if self._stopped or session_id in self._shell_notifications_disabled:
+            return None
+        return self._shell_notification_generations.get(session_id, 0)
+
+    def disable_shell_notifications(self, session_id: str) -> None:
+        self._shell_notification_generations[session_id] = self._shell_notification_generations.get(session_id, 0) + 1
+        self._shell_notifications_disabled.add(session_id)
+
+    def resume_shell_notifications(self, session_id: str) -> None:
+        self._shell_notifications_disabled.discard(session_id)
+
     async def replay_session_history(self, session_id: str) -> None:
         """Replay an initialized session's transcript to the display."""
         await self._operation_dispatcher.replay_session_history(session_id)
@@ -350,7 +420,9 @@ class RuntimeFacade:
         return self._operation_dispatcher.current_agent
 
     def has_running_tasks(self) -> bool:
-        return any(not active.task.done() for active in self._operation_dispatcher.list_active_tasks())
+        return self.shell_task_manager.has_running_tasks() or any(
+            not active.task.done() for active in self._operation_dispatcher.list_active_tasks()
+        )
 
     def cancel_auto_away_summary(self, session_id: str) -> None:
         self._operation_dispatcher.cancel_auto_away_summary(session_id)
@@ -365,6 +437,8 @@ class RuntimeFacade:
 
         closed = await self.session_registry.close_session(session_id, force=force)
         if closed:
+            self.disable_shell_notifications(session_id)
+            await self.shell_task_manager.stop_session(session_id)
             for request in cancelled_requests:
                 await self._operation_dispatcher.emit_event(
                     events.UserInteractionCancelledEvent(
@@ -392,7 +466,12 @@ class RuntimeFacade:
         # Never reclaim the primary (TUI-active) session or any session an
         # exclusion provider vouches for (the server excludes every session
         # with a live WS attach — an attached-but-quiet TUI is still in use).
-        exclude: set[str] = set()
+        exclude: set[str] = self.shell_task_manager.active_session_ids()
+        exclude |= {
+            actor.session_id
+            for actor in self.session_registry.list_session_actors()
+            if self.has_pending_shell_notifications(actor.session_id)
+        }
         primary = self._operation_dispatcher.current_session_id()
         if primary is not None:
             exclude.add(primary)
@@ -412,6 +491,7 @@ class RuntimeFacade:
 
     async def stop(self) -> None:
         self._stopped = True
+        await self.shell_task_manager.aclose()
         sessions_to_flush: list[Agent] = []
         for runtime in self.session_registry.list_session_actors():
             agent = runtime.get_agent()
@@ -459,6 +539,12 @@ class RuntimeFacade:
         log_debug("RuntimeFacade stopped", debug_type=DebugType.EXECUTION)
 
     async def _execute_operation(self, operation: op.Operation) -> None:
+        if (
+            isinstance(operation, op.RunAgentOperation)
+            and operation.shell_notification_generation is not None
+            and self.shell_notification_generation(operation.session_id) != operation.shell_notification_generation
+        ):
+            return
         try:
             log_debug(
                 f"Handling operation {operation.id} of type {operation.type.value}",

{klaude_code-2.34.0 → klaude_code-2.35.0}/src/klaude_code/cli/headless_cmd.py

@@ -692,9 +692,23 @@ def ps_command(
 # -- brief --
 
 
+def _truncate_middle(text: str, limit: int) -> str:
+    if len(text) <= limit:
+        return text
+    marker = "\n… [middle truncated] …\n"
+    if limit <= len(marker):
+        return text[: max(0, limit - 1)] + "…" if limit > 0 else ""
+    remaining = limit - len(marker)
+    head = (remaining + 1) // 2
+    tail = remaining // 2
+    return text[:head] + marker + (text[-tail:] if tail else "")
+
+
 def brief_command(
     target: str = typer.Argument(..., metavar="TARGET"),
-    max_chars: int = typer.Option(2000, "--max-chars", show_default=False, help="Output budget (default 2000)"),
+    max_chars: int = typer.Option(
+        4000, "--max-chars", min=1, show_default=False, help="Target output size (default 4000)"
+    ),
     full_last: bool = typer.Option(False, "--full-last", help="Do not truncate the last assistant message"),
     json_: bool = typer.Option(False, "--json", help="Machine-readable"),
 ) -> None:
@@ -703,9 +717,13 @@ def brief_command(
     Never dumps the full transcript.
 
     \b
-    Sections: state, title, model, dir, todos, current/last tool call,
-    pending request (when waiting_input), last assistant message
-    (truncated), token usage, changed-files summary.
+    Sections: state, title, model, dir, latest user request, todos, current tool call,
+    recent tool calls from the latest user turn (up to 5, with result status),
+    pending request (when waiting_input), recent assistant messages (up to 5,
+    older messages middle-truncated), token usage, changed-files summary.
+    The latest message gets the text budget first; --full-last keeps it whole.
+    In-progress assistant text is included and marked as streaming.
+    Metadata and pending requests are never cut to meet the budget.
     """
     body = _api("GET", f"/api/headless/sessions/{target}/brief")
     if json_:
@@ -727,6 +745,8 @@ def brief_command(
         lines.append(f"agent: {body.get('agent_type')}")
     if body.get("approval_policy"):
         lines.append(f"approval: {body.get('approval_policy')}")
+    if body.get("last_user_message"):
+        lines.append(f"request: {body.get('last_user_message')}")
 
     todos = body.get("todos") or []
     if todos:
@@ -738,6 +758,12 @@ def brief_command(
     if body.get("current_tool_call"):
         lines.append(f"current tool: {body.get('current_tool_call')}")
 
+    recent_tools = body.get("recent_tool_calls") or []
+    if recent_tools:
+        lines.append("recent tools:")
+        for tool in recent_tools:
+            lines.append(f"  [{tool.get('status')}] {tool.get('activity')}")
+
     pending = body.get("pending_request")
     if isinstance(pending, dict):
         lines.extend(_pending_request_lines(pending, target=target))
@@ -753,20 +779,36 @@ def brief_command(
         )
 
     changes = body.get("file_change_summary") or {}
-    edited = list(changes.get("edited_files") or []) + list(changes.get("created_files") or [])
+    edited = list(dict.fromkeys([*(changes.get("edited_files") or []), *(changes.get("created_files") or [])]))
     if edited or changes.get("diff_lines_added") or changes.get("diff_lines_removed"):
+        work_dir = str(body.get("work_dir") or "").rstrip("/")
+        paths = [_abbrev_home(str(path).removeprefix(f"{work_dir}/")) for path in edited[:8]]
+        more = f", … {len(edited) - 8} more" if len(edited) > 8 else ""
         lines.append(
             f"files: +{changes.get('diff_lines_added', 0)}/-{changes.get('diff_lines_removed', 0)} "
-            f"({', '.join(edited[:8])})"
+            f"({', '.join(paths)}{more})"
         )
 
     last_message = str(body.get("last_assistant_message") or "")
     if last_message:
-        used = sum(len(line) + 1 for line in lines) + len("last message:\n")
+        last_label = "last message (streaming):" if body.get("assistant_streaming") else "last message:"
+        used = sum(len(line) + 1 for line in lines) + len(last_label) + 2
         budget = max(200, max_chars - used)
-        if not full_last and len(last_message) > budget:
-            last_message = last_message[:budget] + "… [truncated, use `klaude output` for full text]"
-        lines.append("last message:")
+        if not full_last:
+            last_message = _truncate_middle(last_message, budget)
+        earlier = list(body.get("recent_assistant_messages") or [])[:-1]
+        remaining = max_chars - used - len(last_message) - len("earlier messages:\n")
+        previews: list[str] = []
+        for text in reversed(earlier):
+            if remaining < 80:
+                break
+            preview = _truncate_middle(str(text), min(300, remaining - 5))
+            previews.append(f"  > {preview}")
+            remaining -= len(previews[-1]) + 1
+        if previews:
+            lines.append("earlier messages:")
+            lines.extend(reversed(previews))
+        lines.append(last_label)
         lines.append(last_message)
 
     typer.echo("\n".join(lines))

{klaude_code-2.34.0 → klaude_code-2.35.0}/src/klaude_code/const.py

@@ -113,7 +113,8 @@ BLOCKED_DEVICE_PATHS = frozenset(
 # Tool - Bash / Shell
 # =============================================================================
 
-BASH_DEFAULT_TIMEOUT_MS = 120000  # Default timeout for bash commands (milliseconds)
+BASH_DEFAULT_TIMEOUT_MS = 1800000  # Hard runtime limit for bash commands (milliseconds)
+BASH_DEFAULT_WAIT_MS = 10000  # Foreground wait before background handoff (milliseconds)
 BASH_TERMINATE_TIMEOUT_SEC = 1.0  # Timeout before escalating to SIGKILL (seconds)
 BASH_MODE_SESSION_OUTPUT_MAX_BYTES = 200 * 1024 * 1024  # Max command output captured for session history
 

{klaude_code-2.34.0 → klaude_code-2.35.0}/src/klaude_code/control/runtime/actor.py

@@ -489,6 +489,7 @@ def _is_control_operation(operation: op.Operation) -> bool:
     return isinstance(
         operation,
         op.FollowUpAgentOperation
+        | op.ManageShellOperation
         | op.InterruptOperation
         | op.UserInteractionRespondOperation
         | op.CloseSessionOperation,