limbo-code 0.3.5__tar.gz → 0.3.6__tar.gz

{limbo_code-0.3.5 → limbo_code-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: limbo-code
-Version: 0.3.5
+Version: 0.3.6
 Summary: A minimal terminal AI coding agent
 Requires-Python: >=3.11
 Requires-Dist: httpx>=0.27

{limbo_code-0.3.5 → limbo_code-0.3.6}/docs/subagents.md

@@ -50,11 +50,14 @@ model: inherit        # inherit | cheap | 具体模型 id
 max_iterations: 40
 isolation: shared     # shared | worktree
 context: brief        # brief（只看任务说明）| fork（带上主对话）
+inherit_prompt: false # 仅 fork：沿用主会话的 system prompt 和工具列表
 scope_paths: packages/api/**
 ---
 给子代理的额外指令。
 ```
 
+`inherit_prompt: true`（内置的 skill-reviewer 就是这样）让 fork 子代理逐字节沿用主会话的 system prompt 和工具定义，第一次请求就能命中 prompt 缓存。工具限制只在执行侧生效：主会话的工具都会展示给它，但不在白名单里的调用会失败。它的角色说明和指令放在第一条消息里；它没有上面那五个任务工具，最后一条纯文本回复就是结果。这个开关只在子代理和主会话用同一个模型时生效，换了模型缓存本来就是冷的，会回到普通 fork。
+
 ## 打点与任务编排
 
 子代理有五个工具：
@@ -121,7 +124,7 @@ enabled = true                 # false：完全关闭
 auto = "suggest"               # off | suggest | on
 max_parallel = 3               # 同时运行的子代理
 max_tasks = 12                 # 未结束任务上限
-task_token_budget = 400000     # 单任务 token 预算，超出即失败（0 = 不限）
+task_token_budget = 400000     # 单任务 token 预算（0 = 不限）：只算新增 token（总量减去缓存命中），超出后当前这批工具跑完、下一次请求前收尾
 cheap_model = ""               # model: cheap 的角色用它（空 = 主模型）
 wake_main_on = ["question", "alert", "wave_done"]
 on_dep_fail = "notify"         # notify | cascade

{limbo_code-0.3.5 → limbo_code-0.3.6}/src/limbo/agent.py

@@ -77,10 +77,11 @@ from limbo.trace import TRACE_SCHEMA, TraceLogger, trace_path_for, utc_now_iso
 # it burns the whole iteration budget re-sending what can never fit.
 _MAX_CONSECUTIVE_LENGTH_STOPS = 3
 
-# Placeholder result for tool calls that never started because the user
-# interrupted the batch (RFC LIM-53). Only ever used for calls that
-# genuinely never ran, so history and disk cannot diverge.
-_NOT_EXECUTED_MESSAGE = "未执行：用户打断（ESC）"
+# Placeholder result for tool calls that never started because the batch
+# was interrupted (RFC LIM-53). Only ever used for calls that genuinely
+# never ran, so history and disk cannot diverge. ``interrupt(reason)``
+# names who stopped it (the supervisor pausing or cancelling a subagent).
+_USER_INTERRUPT_REASON = "用户打断（ESC）"
 
 
 class _StreamInterrupted(Exception):
@@ -139,6 +140,8 @@ class UsageUpdate:
     """Cumulative token usage for the session, emitted after each LLM call."""
 
     total_tokens: int
+    # Tokens the provider had to process anew: total minus cache hits.
+    fresh_tokens: int = 0
 
 
 @dataclass(frozen=True)
@@ -233,7 +236,11 @@ class Agent:
         # stream / tool batch / compact summary at the nearest
         # history-consistency point.
         self._interrupt_requested = False
+        self._interrupt_reason = _USER_INTERRUPT_REASON
         self._turn_interrupted = False
+        # request_stop(): end the turn at the next loop top, before another
+        # request goes out (the current tool batch still runs).
+        self._stop_reason: str | None = None
         self._stream_task: asyncio.Task[Any] | None = None
         self._stream_cut = False
         self._iteration_count = 0
@@ -244,6 +251,11 @@ class Agent:
         # Extra system-prompt section and tools installed after
         # construction (subagent orchestration, see install()).
         self._prompt_extra = ""
+        # Cache parity (install()): a fork child sends its parent's exact
+        # system prompt and tool definitions so the provider's prefix cache
+        # hits; the child's own registry and hooks still decide dispatch.
+        self._system_override: str | None = None
+        self._advertised_tools: list[dict[str, Any]] | None = None
         # Frozen memory snapshot (limbo.memory): taken once per session so
         # mid-session memory writes never change the prompt prefix.
         store = self.registry.memory_store
@@ -498,6 +510,22 @@ class Agent:
         """Cumulative tokens across every model this session has used."""
         return sum(entry.total_tokens for entry in self._meta.usage.values())
 
+    @property
+    def session_fresh_tokens(self) -> int:
+        """Cumulative tokens minus prompt-cache hits: what the provider had
+        to process anew. Re-sending a cached prefix every iteration costs
+        little, so budgets count this, not ``session_total_tokens``."""
+        return sum(
+            max(0, entry.total_tokens - entry.cached_tokens)
+            for entry in self._meta.usage.values()
+        )
+
+    def _usage_update(self) -> UsageUpdate:
+        return UsageUpdate(
+            total_tokens=self.session_total_tokens,
+            fresh_tokens=self.session_fresh_tokens,
+        )
+
     @property
     def usage_ledger(self) -> dict[str, UsageEntry]:
         return dict(self._meta.usage)
@@ -616,12 +644,19 @@ class Agent:
         hooks: Sequence[ToolHook] = (),
         remove_tools: Sequence[str] = (),
         prompt_section: str = "",
+        system_prompt: str | None = None,
+        advertised_tools: list[dict[str, Any]] | None = None,
     ) -> None:
         """Extend this agent after construction (subagent orchestration).
 
         Registers tool instances and hooks, removes tools a profile does
         not grant, and appends ``prompt_section`` to the system prompt,
         which is rebuilt in place (resume regenerates it anyway).
+
+        ``system_prompt`` / ``advertised_tools`` replace what the model is
+        shown verbatim (cache parity with a parent session); calls are
+        still dispatched through this agent's own registry, so a tool that
+        is advertised but not registered fails as unknown.
         """
         for name in remove_tools:
             self.registry.unregister(name)
@@ -630,6 +665,10 @@ class Agent:
         self.registry.hooks.extend(hooks)
         if prompt_section:
             self._prompt_extra = prompt_section
+        if system_prompt is not None:
+            self._system_override = system_prompt
+        if advertised_tools is not None:
+            self._advertised_tools = advertised_tools
         self._init_system_message()
 
     @property
@@ -642,9 +681,12 @@ class Agent:
         return self._end_turn_requested
 
     def _init_system_message(self) -> None:
-        prompt = build_system_prompt(self.registry, self.workdir, memory=self._memory)
-        if self._prompt_extra:
-            prompt += "\n\n" + self._prompt_extra
+        if self._system_override is not None:
+            prompt = self._system_override
+        else:
+            prompt = build_system_prompt(self.registry, self.workdir, memory=self._memory)
+            if self._prompt_extra:
+                prompt += "\n\n" + self._prompt_extra
         if self.messages and self.messages[0].role == "system":
             # Code Mode toggles rebuild the system prompt in place (the
             # SDK section changes with the presentation).
@@ -652,6 +694,19 @@ class Agent:
         else:
             self.messages.append(Message(role="system", content=prompt))
 
+    @property
+    def system_prompt(self) -> str:
+        """The system prompt the next request sends."""
+        if self.messages and self.messages[0].role == "system":
+            return self.messages[0].content or ""
+        return ""
+
+    def tool_definitions(self) -> list[dict[str, Any]]:
+        """The tool definitions the next request sends."""
+        if self._advertised_tools is not None:
+            return self._advertised_tools
+        return self.registry.definitions()
+
     @property
     def messages(self) -> list[Message]:
         """The conversation history (owned by the tool-call bookkeeper)."""
@@ -833,7 +888,7 @@ class Agent:
 
     # -- interrupt (LIM-53) ---------------------------------------------------
 
-    def interrupt(self) -> None:
+    def interrupt(self, reason: str = _USER_INTERRUPT_REASON) -> None:
         """Interrupt the current turn / compact at the next consistency point.
 
         Non-blocking; safe to call from the UI at any time (a no-op when
@@ -845,11 +900,27 @@ class Agent:
         cancellable by design (they finish and record real results).
         """
         self._interrupt_requested = True
+        self._interrupt_reason = reason
         task = self._stream_task
         if task is not None and not task.done():
             task.cancel()
         self.registry.cancel_active()
 
+    def request_stop(self, reason: str) -> None:
+        """End the current turn before its next LLM request.
+
+        Unlike interrupt() nothing is cancelled: the in-flight response
+        and its tool batch complete and are recorded, then the loop top
+        stops instead of sending another request (a subagent over its
+        token budget). Reset at run() entry; see ``stop_reason``.
+        """
+        self._stop_reason = reason
+
+    @property
+    def stop_reason(self) -> str | None:
+        """Why request_stop() ended the last turn (None: it did not)."""
+        return self._stop_reason
+
     @property
     def last_run_failed(self) -> bool:
         """Whether the last turn ended on an LLM error (after its retries).
@@ -964,7 +1035,9 @@ class Agent:
         # RFC LIM-53: an interrupt requested while idle must not leak into
         # this turn (one of the two reset points; compact() is the other).
         self._interrupt_requested = False
+        self._interrupt_reason = _USER_INTERRUPT_REASON
         self._turn_interrupted = False
+        self._stop_reason = None
         self._turn_count += 1
         self._turn_start = time.monotonic()
         self._turn_started_at = utc_now_iso()
@@ -1135,6 +1208,16 @@ class Agent:
 
     async def _conversation_loop(self) -> AsyncIterator[AgentEvent]:
         while self._iteration_count < self.config.llm.max_iterations:
+            if self._stop_reason is not None:
+                # request_stop(): history is consistent here (the previous
+                # batch is recorded) and nothing is in flight.
+                self.trace.log(
+                    "turn_stopped",
+                    turn=self._turn_count,
+                    iteration=self._iteration_count,
+                    reason=self._stop_reason,
+                )
+                break
             self._iteration_count += 1
             # Loop-top check: history is consistent here (all tool results
             # from the previous batch are recorded) and no request has been
@@ -1365,7 +1448,7 @@ class Agent:
                 # start of the batch (cancel_active() had nothing to kill
                 # yet) — no call starts, every call gets the placeholder.
                 for tc in tool_calls:
-                    result = ToolResult(success=False, error=_NOT_EXECUTED_MESSAGE)
+                    result = ToolResult(success=False, error=f"未执行：{self._interrupt_reason}")
                     results[tc["id"]] = result
                     unexecuted.append(tc["id"])
                     yield ToolResultEvent(
@@ -1395,7 +1478,7 @@ class Agent:
                     # Only genuinely un-executed calls get it — started
                     # tools always record their real result, so history
                     # and disk cannot diverge.
-                    result = ToolResult(success=False, error=_NOT_EXECUTED_MESSAGE)
+                    result = ToolResult(success=False, error=f"未执行：{self._interrupt_reason}")
                     unexecuted.append(tc["id"])
                 else:
                     admission = (await self._admit([tc]))[tc["id"]]
@@ -1555,7 +1638,7 @@ class Agent:
                     pass
 
     async def _call_llm(self) -> AsyncIterator[AgentEvent]:
-        tool_definitions = self.registry.definitions()
+        tool_definitions = self.tool_definitions()
         assistant_content = ""
         assistant_reasoning = ""
         assistant_signature: str | None = None
@@ -1678,7 +1761,7 @@ class Agent:
         totals = self.record_usage(usage)
         self._last_finish_reason = meta.finish_reason if meta else None
         if totals.total_tokens:
-            yield UsageUpdate(total_tokens=self.session_total_tokens)
+            yield self._usage_update()
         self.trace.log(
             "llm_response",
             turn=self._turn_count,
@@ -1907,7 +1990,7 @@ class Agent:
         )
         # The summary call is billed too: refresh the counter.
         if self.session_total_tokens:
-            yield UsageUpdate(total_tokens=self.session_total_tokens)
+            yield self._usage_update()
 
     def _save_session_sync(self) -> None:
         """Persist the session: incremental append by default, full rewrite

{limbo_code-0.3.5 → limbo_code-0.3.6}/src/limbo/app.py

@@ -29,13 +29,18 @@ def _apply_kitty_keyboard_workaround(config) -> None:
 
     Textual reads TEXTUAL_DISABLE_KITTY_KEY at import time, so this must run
     before the first `textual` import. See KittyKeyboardMode for why typing
-    Chinese inside the herdr multiplexer turns into spaces when the kitty
-    keyboard protocol is enabled.
+    Chinese inside the herdr multiplexer turns into spaces under the full
+    kitty keyboard protocol, and why herdr still needs the disambiguate flag.
     """
-    if config.ui.kitty_keyboard.disable_textual_kitty_key(
-        in_herdr=bool(os.environ.get("HERDR_ENV"))
-    ):
+    mode = config.ui.kitty_keyboard
+    if mode.disable_textual_kitty_key():
         os.environ["TEXTUAL_DISABLE_KITTY_KEY"] = "1"
+    elif mode.disambiguate_only(in_herdr=bool(os.environ.get("HERDR_ENV"))):
+        from limbo.ui.key_fixes import (  # noqa: PLC0415 - imports textual; must follow the env check above
+            request_kitty_disambiguate_only,
+        )
+
+        request_kitty_disambiguate_only()
 
 
 def _first_run_login(spec, config) -> bool:  # noqa: ANN001

{limbo_code-0.3.5 → limbo_code-0.3.6}/src/limbo/config.py

@@ -138,23 +138,33 @@ class KittyKeyboardMode(str, Enum):
     terminal (e.g. Ghostty), and Ghostty then encodes IME commits as the
     physical commit key (space) while dropping the composed text — typing
     Chinese turns into spaces (pasting is unaffected, it bypasses the key
-    encoder). Disabling the protocol makes herdr negotiate IME-compatible host
-    flags so committed IME text arrives as raw UTF-8.
+    encoder).
+
+    Turning the protocol off entirely is not an option either: herdr then
+    encodes Shift+Enter for the pane as a bare ``\r`` (indistinguishable from
+    Enter), so the input box can no longer insert a newline. Requesting only
+    ``DISAMBIGUATE_ESCAPE_CODES`` is the middle ground: herdr leaves the host
+    flags alone (IME text still arrives as raw UTF-8) and forwards Shift+Enter
+    as ``ESC [ 13 ; 2 u``.
     """
 
-    # Disable only inside the herdr multiplexer (detected via HERDR_ENV);
-    # keep the protocol everywhere else. Safe default for CJK users.
+    # Inside the herdr multiplexer (detected via HERDR_ENV) request only the
+    # disambiguate flag; the full Textual request everywhere else. Safe
+    # default for CJK users.
     AUTO = "auto"
-    # Always request the kitty keyboard protocol (Textual's default behavior).
+    # Always request the full kitty keyboard protocol (Textual's default).
     ENABLED = "enabled"
-    # Never request it — forces raw/legacy terminal input everywhere.
+    # Never request it — forces raw/legacy terminal input everywhere
+    # (Shift+Enter is then indistinguishable from Enter inside herdr).
     DISABLED = "disabled"
 
-    def disable_textual_kitty_key(self, *, in_herdr: bool) -> bool:
+    def disable_textual_kitty_key(self) -> bool:
         """Whether Textual's kitty keyboard protocol should be disabled."""
-        return self is KittyKeyboardMode.DISABLED or (
-            self is KittyKeyboardMode.AUTO and in_herdr
-        )
+        return self is KittyKeyboardMode.DISABLED
+
+    def disambiguate_only(self, *, in_herdr: bool) -> bool:
+        """Whether to request only the kitty disambiguate flag."""
+        return self is KittyKeyboardMode.AUTO and in_herdr
 
 
 class UIConfig(BaseModel):
@@ -169,8 +179,9 @@ class UIConfig(BaseModel):
     # full, or reduced inside an SSH session. LIMBO_MOTION overrides it.
     motion: str | None = None
     # Kitty keyboard protocol handling (see KittyKeyboardMode):
-    #   auto     - enable normally, except inside the herdr multiplexer where
-    #              it breaks IME/Chinese input (default)
+    #   auto     - enable normally; inside the herdr multiplexer request only
+    #              the disambiguate flag, the full set breaks IME/Chinese
+    #              input there (default)
     #   enabled  - always request the kitty keyboard protocol
     #   disabled - never request it (forces raw/legacy terminal input)
     kitty_keyboard: KittyKeyboardMode = KittyKeyboardMode.AUTO
@@ -325,7 +336,9 @@ class SubagentSettings(BaseModel):
     # Live (unfinished) tasks at a time. Subagents never plan themselves
     # (depth 1): they can only propose_task, which the main agent approves.
     max_tasks: int = 12
-    # Per-task token budget (0 = unlimited); a task over budget fails.
+    # Per-task budget of fresh tokens (total minus prompt-cache hits;
+    # 0 = unlimited). Over it, the current tool batch completes and the
+    # task ends before its next request, reporting what it changed.
     task_token_budget: int = 400_000
     # Model for profiles with ``model: cheap`` (empty = the main model).
     cheap_model: str = ""

{limbo_code-0.3.5 → limbo_code-0.3.6}/src/limbo/llm/catalog.py

@@ -255,6 +255,18 @@ CATALOG: dict[str, ModelSpec] = {
     # 64K default output cap is deliberately conservative — thinking
     # tokens count toward the output limit, so a near-max cap would let a
     # long chain of thought starve the visible answer.
+    # deepseek-flash is the official Flash name (DeepSeek-V4.1-Flash, per
+    # the pricing page 2026-10): 1M context, 384K max output, image input.
+    # deepseek-v4-flash / -vision-exp are legacy aliases served by it.
+    "deepseek-flash": ModelSpec(
+        id="deepseek-flash",
+        provider=DEEPSEEK,
+        context_window=1_000_000,
+        max_tokens=65_536,
+        reasoning=True,
+        vision=True,
+        thinking_format="deepseek",
+    ),
     "deepseek-v4-pro": ModelSpec(
         id="deepseek-v4-pro",
         provider=DEEPSEEK,
@@ -328,7 +340,13 @@ CATALOG: dict[str, ModelSpec] = {
     "k3": _kimi_coding(
         "k3", context_window=1_048_576, max_tokens=131_072
     ),
-    "kimi-for-coding": _kimi_coding("kimi-for-coding"),
+    # k3-256k: K3 capped at 256K context (images only, no video).
+    "k3-256k": _kimi_coding("k3-256k"),
+    # kimi-for-coding now serves K2.8 Preview with a 1M window; highspeed
+    # stays at 256K (Kimi Code models page, 2026-10).
+    "kimi-for-coding": _kimi_coding(
+        "kimi-for-coding", context_window=1_048_576, max_tokens=131_072
+    ),
     "kimi-for-coding-highspeed": _kimi_coding("kimi-for-coding-highspeed"),
     # -- GLM Coding Plan (subscription whitelist) ----------------------------
     "glm-4.5-air": _glm("glm-4.5-air", context_window=131_072, max_tokens=98_304),

{limbo_code-0.3.5 → limbo_code-0.3.6}/src/limbo/subagents/profiles.py

@@ -12,8 +12,11 @@ Frontmatter keys: ``name``, ``description``, ``when_to_use``, ``tools``
 (``read_only`` | ``all`` | ``no_edit`` | comma list), ``model``
 (``inherit``, ``cheap`` or a model id), ``max_iterations``,
 ``isolation`` (``shared`` | ``worktree``), ``context`` (``brief`` |
-``fork``), ``scope_paths`` (comma list). The body is the profile's
-instructions, appended to the subagent's system prompt.
+``fork``), ``inherit_prompt`` (``true``: a fork child keeps the main
+session's system prompt and tool list for prompt-cache parity),
+``scope_paths`` (comma list). The body is the profile's instructions,
+appended to the subagent's system prompt (with ``inherit_prompt``, sent in
+its first message instead).
 """
 
 from __future__ import annotations
@@ -73,6 +76,10 @@ class Profile:
     isolation: str = "shared"
     context: str = "brief"  # brief | fork
     scope_paths: tuple[str, ...] = ()
+    # context=fork only: keep the main session's system prompt and tool
+    # list verbatim (prompt-cache parity); the body and role go in the
+    # first message and the final reply is the result (no task tools).
+    inherit_prompt: bool = False
     body: str = ""
     path: Path | None = None
     builtin: bool = False
@@ -174,6 +181,7 @@ BUILTIN_PROFILES: tuple[Profile, ...] = (
         model="cheap",
         max_iterations=20,
         context="fork",
+        inherit_prompt=True,
         body=SKILL_REVIEW_PROMPT,
         builtin=True,
     ),
@@ -210,6 +218,7 @@ def parse_profile_md(text: str, fallback_name: str, path: Path | None = None) ->
         if fields.get("context") in ("brief", "fork")
         else "brief",
         scope_paths=tuple(s.strip().strip("\"'") for s in scope.split(",") if s.strip()),
+        inherit_prompt=fields.get("inherit_prompt", "").lower() in ("true", "yes", "1"),
         body=body.strip(),
         path=path,
     )
@@ -284,6 +293,8 @@ def render_profile_md(profile: Profile) -> str:
         f"isolation: {profile.isolation}",
         f"context: {profile.context}",
     ]
+    if profile.inherit_prompt:
+        lines.append("inherit_prompt: true")
     if profile.scope_paths:
         lines.append("scope_paths: " + ", ".join(profile.scope_paths))
     lines += ["---", profile.body, ""]

{limbo_code-0.3.5 → limbo_code-0.3.6}/src/limbo/subagents/supervisor.py

@@ -33,7 +33,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
-from limbo.agent import ErrorEvent, TextDelta, ToolCallRequest, UsageUpdate
+from limbo.agent import ErrorEvent, TextDelta, ToolCallRequest, ToolResultEvent, UsageUpdate
 from limbo.config import Config
 from limbo.llm.client import LLMClient
 from limbo.sessions import save_session
@@ -62,7 +62,7 @@ from limbo.subagents.events import (
     PlanProposed,
     TaskChanged,
 )
-from limbo.subagents.hooks import ClaimHook, NoEditHook, ReadOnlyHook
+from limbo.subagents.hooks import SUBAGENT_TOOL_NAMES, ClaimHook, NoEditHook, ReadOnlyHook
 from limbo.subagents.profiles import (
     NO_EDIT,
     READ_ONLY,
@@ -131,6 +131,20 @@ user does not watch you live.
   finish(status="failed") and say why.
 {scope}{others}</subagent_role>"""
 
+# A cache-parity fork child (profile inherit_prompt) keeps the main
+# session's system prompt and tool list byte for byte, so its role travels
+# in the first user message instead, and it has no task tools of its own:
+# its final plain-text reply is the result.
+FORK_CHILD_PROMPT = """<subagent_role>
+From here on you are the subagent "{agent}" of limbo, working on task {id}:
+{title}. The conversation above is the main session's, shown for context;
+the user does not watch you live.
+- The tool list is the main session's, but you may only call: {tools}.
+  Any other tool fails.
+- When you are done, reply with your result as plain text and no tool
+  calls: that reply is all the main agent reads.
+</subagent_role>"""
+
 
 @dataclass
 class PlanResult:
@@ -148,6 +162,10 @@ class _Runner:
     last_text: str = ""
     last_error: str = ""
     over_budget: bool = False
+    budget_reason: str = ""
+    # First line of every successful state-changing call (named in the
+    # outcome when the budget ends the task before it reports).
+    writes: list[str] = field(default_factory=list)
     resumed: bool = False
 
 
@@ -396,6 +414,7 @@ class Supervisor:
                 async for event in agent.run(text):
                     self._observe(runner, event)
                 if runner.over_budget:
+                    self._finish_over_budget(runner)
                     break
                 if self.board.get(task_id).status != "running":
                     break
@@ -460,20 +479,49 @@ class Supervisor:
                 self._set_activity(task_id, "✎ 回复中")
         elif isinstance(event, ErrorEvent):
             runner.last_error = event.message
+        elif isinstance(event, ToolResultEvent):
+            agent = runner.agent
+            if (
+                event.result.success
+                and event.name not in SUBAGENT_TOOL_NAMES
+                and agent is not None
+                and agent.registry.replay_policy(event.name) != "safe"
+            ):
+                first = (event.result.output or "").strip().splitlines()
+                runner.writes.append(f"{event.name}：{first[0][:160] if first else '完成'}")
         elif isinstance(event, UsageUpdate):
             self._tokens[task_id] = event.total_tokens
             task = self.board.tasks.get(task_id)
             budget = task.max_tokens if task is not None else 0
-            if budget and event.total_tokens > budget and not runner.over_budget:
+            # The budget counts fresh tokens: a fork child re-sends the
+            # whole inherited conversation every iteration, and those cache
+            # hits would otherwise exhaust it in a handful of requests.
+            if budget and event.fresh_tokens > budget and not runner.over_budget:
                 runner.over_budget = True
-                if runner.agent is not None:
-                    runner.agent.interrupt()
-                self._finish(
-                    task_id,
-                    summary=runner.last_text,
-                    failed=True,
-                    reason=f"超出 token 预算（{event.total_tokens} > {budget}）",
+                runner.budget_reason = (
+                    f"超出 token 预算（新增 {event.fresh_tokens} > {budget}，缓存命中不计）"
                 )
+                # Not interrupt(): the response that crossed the line and
+                # its tool batch complete (their writes land), then the
+                # turn ends before the next request.
+                if runner.agent is not None:
+                    runner.agent.request_stop(runner.budget_reason)
+
+    def _finish_over_budget(self, runner: _Runner) -> None:
+        """The budget ended the turn: report what the task got done."""
+        task = self.board.tasks.get(runner.task_id)
+        if task is None or task.terminal:
+            return  # it called finish in the crossing batch
+        lines = [runner.budget_reason + "，已在下一次请求前收尾，结果可能不完整"]
+        if runner.writes:
+            lines.append("已执行的改动：\n" + "\n".join(f"- {w}" for w in runner.writes[-20:]))
+        text = runner.last_text.strip()
+        self._finish(
+            runner.task_id,
+            summary=text,
+            failed=not (text or runner.writes),
+            reason="\n".join(lines),
+        )
 
     def _set_activity(self, task_id: str, text: str) -> None:
         self._activity[task_id] = text
@@ -545,6 +593,17 @@ class Supervisor:
         self._configure(agent, task, profile, workdir)
         return agent, resumed
 
+    def _inherits_prompt(self, task: Task, profile: Profile) -> bool:
+        """Cache parity (hermes' background review): a fork child on the
+        main model sends the main session's exact prefix, so even its first
+        request is a prompt-cache hit. On another model the cache is cold
+        anyway and the child keeps its own prompt and task tools."""
+        return (
+            task.context == "fork"
+            and profile.inherit_prompt
+            and self._model_for(profile) == self.main.config.llm.model
+        )
+
     def _write_fork(self, path: Path, task: Task) -> None:
         """context=fork: the child starts from the main history up to the
         current turn's user message (never a half-finished tool batch)."""
@@ -587,6 +646,18 @@ class Supervisor:
             hooks.append(NoEditHook())
         if profile.writes and task.isolation == "shared":
             hooks.append(ClaimHook(task.id, self.board, workdir))
+        if self._inherits_prompt(task, profile):
+            # Advertising is not permission: the main tool list is shown,
+            # the child's trimmed registry and hooks decide what runs.
+            agent.install(
+                hooks=hooks,
+                remove_tools=remove,
+                system_prompt=self.main.system_prompt,
+                advertised_tools=self.main.tool_definitions(),
+            )
+            if hasattr(agent.llm_client, "prompt_cache_key"):
+                agent.llm_client.prompt_cache_key = self.main.session_id
+            return
         agent.install(
             tools=subagent_tools(workdir, self, task.id),
             hooks=hooks,
@@ -625,6 +696,16 @@ class Supervisor:
                 parts.append("主 agent / 用户补充：\n" + inbox)
             return "\n\n".join(parts)
         parts = [f"任务 {task.id}：{task.title}", task.brief.strip()]
+        profile = resolve_profile(self.profiles, task.profile)
+        if self._inherits_prompt(task, profile):
+            names = profile.tool_names or []
+            role = FORK_CHILD_PROMPT.format(
+                agent=task.agent_name,
+                id=task.id,
+                title=task.title,
+                tools=", ".join(names) or "（主会话的全部工具）",
+            )
+            parts = [role, profile.body, *parts]
         if task.acceptance:
             parts.append(f"验收标准：{task.acceptance}")
         if task.scope_paths:
@@ -645,7 +726,7 @@ class Supervisor:
         self._stopped = True
         for runner in list(self._runners.values()):
             if runner.agent is not None:
-                runner.agent.interrupt()
+                runner.agent.interrupt("limbo 退出，任务会在下次启动时恢复")
             if runner.future is not None:
                 runner.future.cancel()
         self.board.set_sink(None)
@@ -951,7 +1032,7 @@ class Supervisor:
         )
         runner = self._runners.get(task.id)
         if runner is not None and runner.agent is not None:
-            runner.agent.interrupt()
+            runner.agent.interrupt("任务被暂停")
         return f"{task.id} 已暂停"
 
     def _resume(self, task: Task, note: str) -> str:
@@ -978,7 +1059,7 @@ class Supervisor:
         )
         runner = self._runners.get(task.id)
         if runner is not None and runner.agent is not None:
-            runner.agent.interrupt()
+            runner.agent.interrupt("任务被取消")
         if by == "system":
             self._push(self._result_notice(self.board.get(task.id)))
         return f"{task.id} 已取消"