god-code 1.0.0__tar.gz → 1.0.1__tar.gz

{god_code-1.0.0 → god_code-1.0.1}/CHANGELOG.md

@@ -2,6 +2,77 @@
 
 All notable changes to God Code will be documented in this file.
 
+## [1.0.1] — 2026-04-07
+
+**Token-efficiency + cancellation closeout.** This release attacks the dominant token cost driver on long dev sessions (planner blocks accumulating in history and rebilling on every subsequent LLM call) and completes the v1.0.0 deferred items (full asyncio.Task cancellation, subprocess termination, per-tool progress events).
+
+**No breaking API changes.** Config additions are opt-out (defaults preserve the new behavior). Event taxonomy gains three additive kinds (`tool_progress`, `plan_pruned`, `planner_skipped`). All 681 v1.0.0 tests continue to pass; 58 new regression tests added (739 total).
+
+### Token efficiency (the main motivator)
+
+- **T1: Planner blocks pruned from history** — `_maybe_run_planner` now calls `prune_system_reports` (a helper that existed and was tested but never wired into production code) to cap plan history at 2 blocks (configurable via `plan_history_keep`). On a 40-turn dev session, this cuts planner-attributable rebill from ~410K tokens to ~2K tokens — roughly $1.2/session saved at gpt-5.4 input rates. Helper extended with an additive `prefix_filter` parameter so pruning is scoped to `"[SYSTEM] Planner pass"` and cannot accidentally drop quality-gate or reviewer reports.
+
+- **T2: Lazy planner triggering** — `_maybe_run_planner` now calls a new `should_run_planner(user_input)` heuristic first. Trivial read-only inputs (`explain X`, `show Y`, `what is in Z`, `如何`, `解釋`, `顯示`, `為什麼`, question marks with `什麼`) skip the full planner cost. Action verbs (EN: implement/add/fix/refactor/... | 繁中: 實作/新增/修/改/重寫) or multi-file references still trigger a plan. Config opt-out: `planner_lazy: false` restores the v1.0.0 unconditional behavior. Emits a new `planner_skipped` event with the reason for dogfood observability.
+
+- **T3: Plan content shaping** — Added `extract_worker_plan()` in `agents/dispatcher.py`. The `[SYSTEM] Planner pass` block injected into main history now contains only the actionable subset (Goal + Steps), not the full 5-section markdown. Scope + Risks + Validation are user-facing context already streamed to the TUI via the planner sub-engine, so they don't need to be re-injected. Typical saving: ~30% of per-plan injected tokens. Defensive fallback: returns the full text unchanged if the LLM produces malformed markdown.
+
+- **T4: `prune_system_reports` wired up** — the helper shipped in v0.x with tests but was dead code. Now in use per T1 above.
+
+### Cancellation closeout (v1.0.0 deferred)
+
+- **D1: Full asyncio.Task cancellation in chat loop** — Completes the v1.0.0/C2 partial implementation. New `_submit_cancellable` helper in `cli/commands.py` wraps `engine.submit()` in `asyncio.create_task`, catches `CancelledError`/`KeyboardInterrupt`, cancels the task, runs cleanup, and raises a new `TurnCancelled` exception (used instead of re-raising `KeyboardInterrupt` because `KeyboardInterrupt` inside an asyncio task trips pytest-asyncio's BaseException handling). Shared cleanup in `_cleanup_after_cancel(engine)` guarded with `hasattr` for FakeEngine compat.
+
+- **D2: Subprocess registry + termination** — New contextvar-based subprocess registry on `ConversationEngine`. `register_subprocess(proc)` / `unregister_subprocess(proc)` / `async terminate_active_subprocesses(timeout=2.0)`. `terminate_active_subprocesses` sends SIGTERM, waits up to 2s, then escalates to SIGKILL for stubborn processes. Activated during `submit()` / `submit_with_images()` via contextvar. Tools lookup the active registry via `get_current_subprocess_registry()`. `tools/godot_cli.run_godot_command` and `tools/screenshot.CaptureScreenshotTool` register their subprocesses on spawn. Ctrl+C during a Godot validate or screenshot capture now kills the subprocess within 2s instead of letting it run to natural completion (30-120s wasted).
+
+- **D3: Per-tool progress events** — Completes v1.0.0/A2 Layer 2. New `tool_progress` event kind + `tools/base.py::emit_tool_progress(context, ...)` helper. `generate_sprite` emits 5 phases (API call → post-process → save → QA → reimport) so the spinner shows `generate_sprite: post-processing (2/5)` instead of a static label. TUI display handler updates the active status spinner's label dynamically.
+
+### Measured impact (design-doc projection)
+
+| Metric | v1.0.0 | v1.0.1 | Delta |
+|---|---|---|---|
+| Planner-attributable rebill (40-turn session) | ~430K tokens | ~18K tokens | **-96%** |
+| Plan history carried (40-turn session) | ~20K tokens | ~700 tokens | **-96%** |
+| Whole-session input tokens (conservative) | baseline | baseline × 0.70-0.92 | **-8% to -30%** |
+| Ctrl+C latency (worst case subprocess) | 30-120s | < 2s | **-95%** |
+
+Actual impact will be measured over the first dogfood session on v1.0.1.
+
+### Added
+
+- `prune_system_reports` `prefix_filter` parameter (scoped pruning)
+- `should_run_planner(user_input)` heuristic
+- `extract_worker_plan(plan_text)` function in dispatcher
+- `plan_history_keep: int = 2` config field
+- `planner_lazy: bool = True` config field
+- `ConversationEngine._active_subprocesses` set
+- `register_subprocess` / `unregister_subprocess` / `terminate_active_subprocesses` engine methods
+- `_activate_subprocess_registry` / `_deactivate_subprocess_registry` engine methods
+- `get_current_subprocess_registry()` module-level accessor
+- `SubprocessRegistryProtocol` typing protocol
+- `TurnCancelled(Exception)` in `cli/commands.py`
+- `_cleanup_after_cancel(engine)` async helper in `cli/commands.py`
+- `_submit_cancellable(engine, user_input, cfg, display)` async helper in `cli/commands.py`
+- `emit_tool_progress(context, ...)` helper in `tools/base.py`
+- New event kinds: `plan_pruned`, `planner_skipped`, `tool_progress`
+
+### Changed
+
+- `_maybe_run_planner`: now checks `should_run_planner` when `planner_lazy=True`, calls `extract_worker_plan` on the planner output before injection, and calls `prune_system_reports` after appending
+- `submit()` / `submit_with_images()`: wrap work in `_activate_subprocess_registry` / `_deactivate_subprocess_registry` context
+- `tools/godot_cli.run_godot_command`: registers subprocess with active registry
+- `tools/screenshot.CaptureScreenshotTool.execute`: registers subprocess with active registry
+- Chat loop (`cli/commands.py`): uses `_submit_cancellable` instead of bare `await engine.submit`
+
+### Test count
+
+681 → 739 (+58 regression tests)
+
+### Known scope notes
+
+- `image_gen` single-candidate API call — the design doc mentioned "4 candidates" but the current `GenerateSpriteTool` requests `n=1` from the image API. Per-tool progress is instead emitted as 5 execution phases (API call, post-process, save, QA, reimport) which covers the full wall-clock.
+- `_run_visual_iteration` engine method doesn't exist as a standalone — the vision loop is LLM-driven via tool calls, not a hardcoded counter. `tool_progress` instrumentation for vision iteration was dropped from this release; the user-visible stage updates come from the individual tool-level progress (screenshot, analyze, score) rather than a synthetic "iteration N/3" counter.
+- Windows cancellation: `asyncio.CancelledError` handling path works cross-platform. The subprocess SIGTERM/SIGKILL path is POSIX-only but macOS/Linux is the current supported platform set. Windows gets best-effort behavior via normal Python subprocess termination.
+
 ## [1.0.0] — 2026-04-07
 
 **Promoted from 1.0.0rc1 with no code changes** after Starfall workflow dogfood verification. See the `[1.0.0rc1]` section below for the full list of fixes and design rationale.

{god_code-1.0.0 → god_code-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: god-code
-Version: 1.0.0
+Version: 1.0.1
 Summary: AI coding agent specialized for Godot game development
 Project-URL: Homepage, https://github.com/888wing/god-code
 Project-URL: Repository, https://github.com/888wing/god-code

{god_code-1.0.0 → god_code-1.0.1}/godot_agent/agents/dispatcher.py

@@ -2,10 +2,57 @@
 
 from __future__ import annotations
 
+import re
 from dataclasses import replace
 from pathlib import Path
 from typing import Callable
 
+
+def extract_worker_plan(plan_text: str) -> str:
+    """Reduce a full planner output to just the actionable subset.
+
+    The planner prompt (v1.0.0/F2) enforces a 5-section markdown format:
+    Goal / Scope / Steps / Risks / Validation. The worker sub-agent and
+    the main engine only need Goal + Steps to execute correctly — Scope,
+    Risks, and Validation are user-facing context that the TUI already
+    shows separately. Injecting them into main history wastes tokens on
+    every subsequent LLM call (v1.0.1/T3).
+
+    Returns the reduced plan. Defensive fallback: if the markdown can't
+    be parsed (malformed LLM output), returns the input unchanged — we
+    never want the worker to lose its plan entirely because of a parser
+    mismatch.
+
+    Empty input returns empty string.
+    """
+    if not plan_text:
+        return ""
+
+    # Try to find the **Goal**: and **Steps**: sections. If either is
+    # missing, we're dealing with malformed output — fall back to the
+    # full text.
+    goal_match = re.search(
+        r"\*\*Goal\*\*\s*:\s*(.+?)(?=\n\s*\*\*|$)",
+        plan_text,
+        re.DOTALL,
+    )
+    steps_match = re.search(
+        r"\*\*Steps\*\*\s*:\s*\n(.+?)(?=\n\s*\*\*(?:Risks|Validation)\*\*|$)",
+        plan_text,
+        re.DOTALL,
+    )
+    if not goal_match or not steps_match:
+        return plan_text  # defensive fallback
+
+    goal = goal_match.group(1).strip()
+    steps = steps_match.group(1).strip()
+
+    return (
+        "## Plan\n\n"
+        f"**Goal**: {goal}\n\n"
+        f"**Steps**:\n{steps}\n"
+    )
+
 from godot_agent.godot.impact_analysis import format_impact_report, infer_request_impact
 from godot_agent.agents.configs import AGENT_CONFIGS, AgentConfig
 from godot_agent.agents.results import AgentTaskResult

{god_code-1.0.0 → god_code-1.0.1}/godot_agent/cli/commands.py

@@ -537,6 +537,76 @@ def ask(prompt: str, project: str, config: str | None, image: tuple[str, ...], p
         click.echo(result)
 
 
+class TurnCancelled(Exception):
+    """Raised by :func:`_submit_cancellable` when the user cancels mid-turn.
+
+    Used as an internal signal between the helper and the chat loop so
+    pytest-asyncio can catch cancellation via ``pytest.raises`` without
+    tripping over KeyboardInterrupt / CancelledError's special handling
+    inside an event loop. The chat loop translates this back into a
+    "Cancelled" message and continues the session.
+    """
+
+
+async def _cleanup_after_cancel(engine) -> None:
+    """Shared cleanup for the cancellation path.
+
+    Calls ``engine.terminate_active_subprocesses()`` (v1.0.1/D2) to
+    SIGTERM + SIGKILL any in-flight subprocesses, then
+    ``engine.rollback_current_turn()`` (v1.0.0/C2) to drop any messages
+    appended during the cancelled turn. Both are guarded with hasattr
+    for FakeEngine compatibility.
+    """
+    if hasattr(engine, "terminate_active_subprocesses"):
+        try:
+            await engine.terminate_active_subprocesses()
+        except Exception:
+            pass
+    if hasattr(engine, "rollback_current_turn"):
+        try:
+            engine.rollback_current_turn()
+        except Exception:
+            pass
+
+
+async def _submit_cancellable(engine, user_input: str, cfg, display) -> str:
+    """Submit a user input as a cancellable asyncio task.
+
+    Wraps ``engine.submit()`` in ``asyncio.create_task`` so that a
+    KeyboardInterrupt (Ctrl+C) during the await can cancel the task,
+    terminate any tool-spawned subprocesses, and roll back the turn's
+    message state — completing the v1.0.0/C2 partial fix with the full
+    cancellation architecture planned in v1.0.1/D1.
+
+    On success: returns the assistant response string.
+
+    On KeyboardInterrupt / CancelledError: cancels the task, awaits it
+    to drain, runs cleanup via ``_cleanup_after_cancel``, then raises
+    ``TurnCancelled`` so the chat loop can catch it and continue the
+    session. Uses a custom exception type (not KeyboardInterrupt) to
+    avoid pytest-asyncio / event loop special handling of BaseException.
+    """
+    submit_task = asyncio.create_task(engine.submit(user_input))
+    try:
+        if cfg.streaming and engine.on_stream_chunk:
+            return await submit_task
+        else:
+            with display.thinking():
+                result = await submit_task
+            display.agent_response(result)
+            return result
+    except (KeyboardInterrupt, asyncio.CancelledError):
+        submit_task.cancel()
+        try:
+            await submit_task
+        except (asyncio.CancelledError, KeyboardInterrupt):
+            pass
+        except Exception:
+            pass
+        await _cleanup_after_cancel(engine)
+        raise TurnCancelled()
+
+
 @main.command()
 @click.option("--project", "-p", default=".", help="Path to Godot project root")
 @click.option("--config", "-c", default=None, help="Path to config file")
@@ -1775,21 +1845,24 @@ def chat(project: str = ".", config: str | None = None):
                         await _edit_intent_profile(checkpoint=True)
                         engine.refresh_intent_profile(user_input)
                         _refresh_workspace()
-                    # v1.0.0/C2: submit returns naturally for both streaming
-                    # and non-streaming paths. KeyboardInterrupt is propagated
-                    # at the next await point and caught below — combined with
-                    # rollback_current_turn(), this ensures cancelled turns
-                    # don't pollute the message history of the next turn.
-                    if cfg.streaming and engine.on_stream_chunk:
-                        response = await engine.submit(user_input)
-                    else:
-                        with display.thinking():
-                            response = await engine.submit(user_input)
-                        display.agent_response(response)
-                except KeyboardInterrupt:
+                    # v1.0.1/D1: fully-cancellable submit. Wraps
+                    # engine.submit() in asyncio.create_task so Ctrl+C
+                    # can cancel the task, terminate any spawned
+                    # subprocesses, and roll back the turn's message
+                    # state (completes v1.0.0/C2). See
+                    # _submit_cancellable docstring for details.
+                    response = await _submit_cancellable(
+                        engine, user_input, cfg, display
+                    )
+                except (KeyboardInterrupt, TurnCancelled):
                     display.info("Cancelled")
-                    if hasattr(engine, "rollback_current_turn"):
-                        engine.rollback_current_turn()
+                    # _submit_cancellable already ran cleanup via
+                    # _cleanup_after_cancel, but if the exception was a
+                    # raw KeyboardInterrupt (e.g. during the
+                    # refresh_intent_profile or _edit_intent_profile
+                    # phase before submit started), run cleanup
+                    # defensively to ensure no partial state leaks.
+                    await _cleanup_after_cancel(engine)
                     continue
                 except httpx.HTTPStatusError as e:
                     status_code = e.response.status_code if e.response is not None else "?"

{god_code-1.0.0 → god_code-1.0.1}/godot_agent/cli/engine_wiring.py

@@ -334,6 +334,11 @@ def _wire_engine_callbacks(
     engine.on_event = display.handle_event
     engine.auto_commit = cfg.auto_commit
     engine.use_streaming = cfg.streaming
+    # v1.0.1/T1+T2: propagate token-efficiency settings from config.
+    # getattr defensively so CLI flow tests that construct configs
+    # without these fields continue to work.
+    engine.planner_lazy = getattr(cfg, "planner_lazy", True)
+    engine.plan_history_keep = getattr(cfg, "plan_history_keep", 2)
     if cfg.streaming:
         engine.on_stream_start = display.agent_streaming_start
         engine.on_stream_chunk = display.agent_streaming_chunk

{god_code-1.0.0 → god_code-1.0.1}/godot_agent/runtime/config.py

@@ -46,6 +46,10 @@ class AgentConfig(BaseModel):
     enabled_skills: list[str] = Field(default_factory=list)
     disabled_skills: list[str] = Field(default_factory=list)
 
+    # Token efficiency (v1.0.1)
+    planner_lazy: bool = True  # Skip planner on trivial read-only turns (T2)
+    plan_history_keep: int = 2  # How many planner blocks to keep in history (T1)
+
     # Backend orchestration
     backend_url: str = ""                    # Empty = direct provider (current behavior)
     backend_cost_preference: str = "balanced"  # economy | balanced | quality

{god_code-1.0.0 → god_code-1.0.1}/godot_agent/runtime/context_manager.py

@@ -241,11 +241,26 @@ def truncate_tool_result(content: str, max_chars: int = 2000) -> str:
     return f"{content[:head_size]}\n[...truncated {omitted} chars...]\n{content[-tail_size:]}"
 
 
-def prune_system_reports(messages: list[Message], max_reports: int = 2) -> list[Message]:
-    """Remove old [SYSTEM] quality/reviewer/playtest reports, keeping latest N."""
+def prune_system_reports(
+    messages: list[Message],
+    max_reports: int = 2,
+    prefix_filter: str | None = None,
+) -> list[Message]:
+    """Remove old [SYSTEM] reports from history, keeping the latest N.
+
+    If ``prefix_filter`` is set, only messages whose content starts with the
+    given prefix are considered for pruning. Other [SYSTEM]-prefixed messages
+    pass through untouched. This lets callers scope the prune to a specific
+    report type (e.g. ``"[SYSTEM] Planner"``) without collateral damage to
+    quality-gate or reviewer reports.
+
+    Backward compat: when ``prefix_filter`` is None, every [SYSTEM]-prefixed
+    message is eligible for pruning (original v1.0.0 behavior).
+    """
+    match_prefix = prefix_filter if prefix_filter is not None else "[SYSTEM]"
     report_indices: list[int] = []
     for i, m in enumerate(messages):
-        if m.role == "user" and isinstance(m.content, str) and m.content.startswith("[SYSTEM]"):
+        if m.role == "user" and isinstance(m.content, str) and m.content.startswith(match_prefix):
             report_indices.append(i)
     if len(report_indices) <= max_reports:
         return messages

{god_code-1.0.0 → god_code-1.0.1}/godot_agent/runtime/engine.py

@@ -2,18 +2,20 @@
 
 from __future__ import annotations
 
+import asyncio
+import contextvars
 import enum
 import json
 import logging
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any, Callable, Protocol
 
 from godot_agent.godot.impact_analysis import ImpactAnalysisReport, analyze_change_impact
 from godot_agent.llm.client import LLMClient, Message, TokenUsage
 from godot_agent.prompts.assembler import PromptAssembler
 from godot_agent.prompts.skill_selector import narrow_tools_for_skills, resolve_skills
-from godot_agent.runtime.context_manager import smart_compact, estimate_message_tokens, truncate_tool_result, compress_step_messages
+from godot_agent.runtime.context_manager import smart_compact, estimate_message_tokens, truncate_tool_result, compress_step_messages, prune_system_reports
 from godot_agent.runtime.execution_plan import ExecutionPlan, PlanStep
 from godot_agent.runtime.design_memory import DesignMemory, GameplayIntentProfile, load_design_memory
 from godot_agent.runtime.events import EngineEvent
@@ -38,6 +40,125 @@ log = logging.getLogger(__name__)
 
 # Compact at 75% of 1.05M context to leave room for current turn
 _COMPACT_THRESHOLD = 787500  # 75% of 1.05M
+
+
+# v1.0.1/D2: subprocess registry context variable. Tools that spawn
+# subprocesses can look up the current engine's registry via
+# get_current_subprocess_registry() and register their process so the
+# engine can terminate it on Ctrl+C. Scoped per-asyncio-task so
+# concurrent engines (e.g. in tests) don't collide.
+_current_subprocess_registry: contextvars.ContextVar[
+    "SubprocessRegistryProtocol | None"
+] = contextvars.ContextVar("_current_subprocess_registry", default=None)
+
+
+class SubprocessRegistryProtocol(Protocol):
+    """Minimal interface a subprocess registry must expose. In practice
+    this is ConversationEngine but tests and alternative runtimes can
+    provide their own."""
+    def register_subprocess(self, proc: Any) -> None: ...
+    def unregister_subprocess(self, proc: Any) -> None: ...
+
+
+def get_current_subprocess_registry() -> "SubprocessRegistryProtocol | None":
+    """Return the currently-active subprocess registry, or None if
+    called outside an engine's submit() scope. Tools use this to opt
+    into cancellable subprocess execution without having the engine
+    passed through every call."""
+    return _current_subprocess_registry.get()
+
+# v1.0.1/T2: lazy planner heuristic — action verbs trigger a plan pass,
+# read-only question words skip it. Kept as module-level frozen sets so
+# should_run_planner can't mutate them across calls.
+_ACTION_VERBS_EN = frozenset({
+    "implement", "add", "create", "build", "fix", "refactor", "rewrite",
+    "change", "update", "delete", "remove", "generate", "migrate",
+    "rename", "extract", "split", "merge", "introduce", "replace",
+})
+_ACTION_VERBS_ZH = frozenset({
+    "實作", "新增", "建立", "修", "重寫", "改", "刪除", "產生", "遷移",
+    "重構", "替換", "抽出", "合併", "引入", "更新", "加入", "加上",
+})
+_READONLY_INTENTS_EN = frozenset({
+    "what", "why", "how", "where", "which", "who", "when",
+    "show", "explain", "read", "list", "find", "describe", "display",
+    "print", "tell", "inspect", "view",
+})
+_READONLY_INTENTS_ZH = frozenset({
+    "為什麼", "如何", "顯示", "解釋", "讀", "列", "描述", "查看",
+    "印出", "看一下", "說明", "介紹",
+})
+# ZH interrogative patterns: if these appear anywhere, the sentence is a
+# question. Separate from _READONLY_INTENTS_ZH because these are positional-
+# independent (e.g. "player.gd 裡面有什麼?" is a question without starting
+# with an interrogative keyword).
+_ZH_INTERROGATIVE_PATTERNS = (
+    "什麼", "什么", "嗎?", "嗎?", "何時", "哪個", "哪裡", "哪里",
+)
+
+
+def should_run_planner(user_input: str) -> tuple[bool, str]:
+    """Heuristic: should the planner run for this user input?
+
+    Returns (run, reason). When run=False the caller should skip the
+    planner pass and emit a planner_skipped event with the reason.
+
+    Rules (in priority order):
+    1. Empty / whitespace-only → skip (caller already guards, this is defence)
+    2. Multiple file paths (res:// or .gd, >= 2) → run (multi-file scope)
+    3. > 5 lines → run (complex requests probably need planning)
+    4. Read-only intent keyword (first-token EN or 繁中 anywhere) → skip
+       — checked BEFORE action verbs so "如何實作 X" (how to implement X)
+       stays a question even though it contains an action verb.
+    5. Explicit action verb (EN or ZH) → run
+    6. Default → run (safe direction, preserves v1.0.0 behavior on ambiguity)
+    """
+    text = user_input.strip()
+    if not text:
+        return False, "empty_input"
+
+    # Rule 2: multiple file paths — strong signal for multi-file change
+    file_refs = text.count("res://") + sum(1 for token in text.split() if token.endswith(".gd"))
+    if file_refs >= 2:
+        return True, f"multi_file:{file_refs}"
+
+    # Rule 3: complex / long requests
+    line_count = text.count("\n") + 1
+    if line_count > 5:
+        return True, f"long_request:{line_count}_lines"
+
+    # Rule 4: read-only intents — checked before action verbs so that
+    # question-framed inputs ("how do I X", "如何 X") are correctly
+    # classified as questions even when they contain action verbs.
+    lower = text.lower()
+    first_token = lower.split()[0] if lower.split() else ""
+    if first_token in _READONLY_INTENTS_EN:
+        return False, f"readonly_intent:{first_token}"
+    # ZH uses prefix matching (not substring) to avoid false positives
+    # like "改 enemy 的血量顯示" matching "顯示" as readonly.
+    for intent in _READONLY_INTENTS_ZH:
+        if text.startswith(intent):
+            return False, f"readonly_intent:{intent}"
+    # Positional-independent ZH interrogative patterns catch cases like
+    # "player.gd 裡面有什麼?" that don't start with a keyword.
+    for pattern in _ZH_INTERROGATIVE_PATTERNS:
+        if pattern in text:
+            return False, f"interrogative:{pattern}"
+
+    # Rule 5: explicit action verbs
+    words = set(lower.split())
+    for verb in _ACTION_VERBS_EN:
+        if verb in words:
+            return True, f"action_verb:{verb}"
+    # ZH action verbs use prefix matching for the same reason as readonly.
+    for verb in _ACTION_VERBS_ZH:
+        if text.startswith(verb):
+            return True, f"action_verb:{verb}"
+
+    # Rule 6: default — run. Preserves v1.0.0 behavior on ambiguous input.
+    return True, "default_run"
+
+
 _FILE_MUTATING_TOOLS = {
     "write_file",
     "edit_file",
@@ -155,6 +276,21 @@ class ConversationEngine:
         self.use_streaming = False
         self.base_allowed_tools: set[str] | None = None
         self.allowed_tools: set[str] | None = None
+        # v1.0.1/T1: how many planner blocks to keep in history. Default 2
+        # keeps the current plan plus one previous for "what did I just do"
+        # context without carrying N>2 worth of stale plans. Override via
+        # config (runtime/config.py `plan_history_keep`) or by setting on
+        # the engine instance directly.
+        self.plan_history_keep: int = 2
+        # v1.0.1/T2: skip the planner pass on trivial read-only turns.
+        # Set to False to restore v1.0.0's unconditional planner behavior.
+        self.planner_lazy: bool = True
+        # v1.0.1/D2: subprocess registry. Tools that spawn subprocesses
+        # (run_godot, screenshot_scene) register them here so Ctrl+C can
+        # terminate the entire subprocess tree, not just the Python
+        # coroutine. Populated via register_subprocess / cleared on
+        # rollback_and_terminate or after tool completion.
+        self._active_subprocesses: set[Any] = set()
         self.active_skills: list[str] = []
         self.skill_mode: str = "auto"
         self.enabled_skills: list[str] = []
@@ -881,17 +1017,61 @@ class ConversationEngine:
         if self.dispatcher is None or self.mode not in {"apply", "fix"} or not _has_meaningful_text(user_input):
             return
 
+        # v1.0.1/T2: lazy planner — skip trivial read-only turns so we don't
+        # pay the full planner cost (LLM call + impact report + plan
+        # injection + rebill) on inputs that gain nothing from a plan pass.
+        if self.planner_lazy:
+            should_plan, reason = should_run_planner(user_input)
+            if not should_plan:
+                self._emit_event(
+                    "planner_skipped",
+                    f"Planner skipped: {reason}",
+                    reason=reason,
+                )
+                return
+
         self._emit_event("planner_started", "Running planner pass")
         if self.project_path:
             self.last_impact_report = analyze_change_impact(Path(self.project_path), set(self.changeset.read_files) or {str(Path(self.project_path) / "project.godot")})
         planner_result = await self.dispatcher.run_planner(user_input)
         self.last_plan = planner_result.content
+        # v1.0.1/T3: inject only the actionable subset (Goal + Steps) into
+        # main history. The full plan with Risks/Validation is already
+        # streamed to the user via the planner sub-engine's TUI output;
+        # injecting it again here just wastes tokens on every rebill.
+        from godot_agent.agents.dispatcher import extract_worker_plan
+        reduced_plan = extract_worker_plan(planner_result.content)
         self.messages.append(
             Message.user(
-                f"[SYSTEM] Planner pass before implementation:\n{planner_result.content}\n"
+                f"[SYSTEM] Planner pass before implementation:\n{reduced_plan}\n"
                 "Follow this plan unless direct inspection or validation proves it wrong."
             )
         )
+        # v1.0.1/T1+T4: prune old planner blocks from history so long sessions
+        # don't accumulate N × 500-token plans that rebill on every subsequent
+        # LLM call. Scoped by prefix so quality-gate / reviewer reports (also
+        # [SYSTEM]-prefixed) are never touched as collateral damage.
+        before_count = sum(
+            1 for m in self.messages
+            if isinstance(m.content, str) and m.content.startswith("[SYSTEM] Planner pass")
+        )
+        self.messages = prune_system_reports(
+            self.messages,
+            max_reports=self.plan_history_keep,
+            prefix_filter="[SYSTEM] Planner pass",
+        )
+        after_count = sum(
+            1 for m in self.messages
+            if isinstance(m.content, str) and m.content.startswith("[SYSTEM] Planner pass")
+        )
+        dropped = before_count - after_count
+        if dropped > 0:
+            self._emit_event(
+                "plan_pruned",
+                f"Pruned {dropped} stale planner block(s) from history",
+                dropped=dropped,
+                kept=after_count,
+            )
         self._emit_event("planner_finished", "Planner pass complete", used_tools=planner_result.used_tools)
 
     async def submit(self, user_input: str) -> str:
@@ -903,10 +1083,18 @@ class ConversationEngine:
         self.last_user_input = user_input
         self.refresh_intent_profile(user_input)
         self._sync_registry_context()
-        await self._maybe_run_planner(user_input)
-        self.messages.append(Message.user(user_input))
-        self._emit_event("turn_started", user_input.splitlines()[0][:120], user_input=user_input)
-        return await self._run_loop(None, use_streaming=self.use_streaming)
+        # v1.0.1/D2: activate this engine as the subprocess registry so
+        # tools spawned during this turn can register their subprocesses
+        # for cancellation. The contextvar is reset in finally so
+        # subsequent engines/tests get a clean state.
+        registry_token = self._activate_subprocess_registry()
+        try:
+            await self._maybe_run_planner(user_input)
+            self.messages.append(Message.user(user_input))
+            self._emit_event("turn_started", user_input.splitlines()[0][:120], user_input=user_input)
+            return await self._run_loop(None, use_streaming=self.use_streaming)
+        finally:
+            self._deactivate_subprocess_registry(registry_token)
 
     def rollback_current_turn(self) -> int:
         """Drop any messages appended since the last submit() began.
@@ -928,16 +1116,77 @@ class ConversationEngine:
         self._emit_event("turn_cancelled", f"turn cancelled, dropped {removed} messages")
         return removed
 
+    # ──────────────────────────────────────────────────────────────────
+    # v1.0.1/D2: subprocess registry API
+    # ──────────────────────────────────────────────────────────────────
+    def register_subprocess(self, proc: Any) -> None:
+        """Register a subprocess so the engine can terminate it on
+        cancellation. Tools call this after ``create_subprocess_exec``
+        and ``unregister_subprocess`` after ``communicate`` completes.
+        """
+        self._active_subprocesses.add(proc)
+
+    def unregister_subprocess(self, proc: Any) -> None:
+        """Remove a subprocess from the active set. Idempotent —
+        unregistering an already-removed process is a no-op."""
+        self._active_subprocesses.discard(proc)
+
+    async def terminate_active_subprocesses(self, timeout: float = 2.0) -> int:
+        """Terminate every registered subprocess that's still running.
+
+        Sends SIGTERM (via ``proc.terminate()``), waits up to ``timeout``
+        for graceful exit, then escalates to SIGKILL for any survivor.
+        Clears the registry after. Returns the number of processes that
+        were still running when this was called (i.e. the count that
+        required termination).
+        """
+        if not self._active_subprocesses:
+            return 0
+        running = [p for p in self._active_subprocesses if p.returncode is None]
+        for proc in running:
+            try:
+                proc.terminate()
+            except ProcessLookupError:
+                pass  # already gone
+        for proc in running:
+            if proc.returncode is not None:
+                continue
+            try:
+                await asyncio.wait_for(proc.wait(), timeout=timeout)
+            except asyncio.TimeoutError:
+                try:
+                    proc.kill()
+                    await proc.wait()
+                except ProcessLookupError:
+                    pass
+        self._active_subprocesses.clear()
+        return len(running)
+
+    def _activate_subprocess_registry(self):
+        """Activate this engine as the current subprocess registry for
+        the duration of a submit() call. Returns a token that must be
+        passed to _deactivate_subprocess_registry to restore the prior
+        state (matching contextvars' set/reset API)."""
+        return _current_subprocess_registry.set(self)
+
+    def _deactivate_subprocess_registry(self, token) -> None:
+        _current_subprocess_registry.reset(token)
+
     async def submit_with_images(self, text: str, images_b64: list[str]) -> str:
         if not images_b64 and not _has_meaningful_text(text):
             return ""
         self.last_user_input = text
         self.refresh_intent_profile(text)
         self._sync_registry_context()
-        await self._maybe_run_planner(text)
-        self.messages.append(Message.user_with_images(text, images_b64))
-        self._emit_event("turn_started", text.splitlines()[0][:120], user_input=text, images=len(images_b64))
-        return await self._run_loop(None, use_streaming=self.use_streaming)
+        # v1.0.1/D2: activate subprocess registry for this turn (see submit)
+        registry_token = self._activate_subprocess_registry()
+        try:
+            await self._maybe_run_planner(text)
+            self.messages.append(Message.user_with_images(text, images_b64))
+            self._emit_event("turn_started", text.splitlines()[0][:120], user_input=text, images=len(images_b64))
+            return await self._run_loop(None, use_streaming=self.use_streaming)
+        finally:
+            self._deactivate_subprocess_registry(registry_token)
 
     def _check_auto_health(self) -> "ContextHealth":
         from godot_agent.runtime.context_health import ContextHealth