klaude-code 2.30.0__tar.gz → 2.31.0__tar.gz

{klaude_code-2.30.0 → klaude_code-2.31.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 2.30.0
+Version: 2.31.0
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic[bedrock]>=0.66.0
 Requires-Dist: chardet>=5.2.0,<6
@@ -152,7 +152,7 @@ compact_model:
   - haiku
 ```
 
-Klaude expands each entry into concrete provider candidates in `provider_list` order, then falls through to the next model in the list. For example, `gpt-5.4` will try available providers such as `gpt-5.4@openai`, `gpt-5.4@github-copilot`, and `gpt-5.4@openrouter` before moving to the next model. Runtime fallback is used for non-retryable provider/model failures such as quota, billing, permission, or model-unavailable errors. `fast_model` is used for session-title generation; `compact_model` is used for compact/helper tasks.
+Klaude expands each entry into concrete provider candidates in `provider_list` order, then falls through to the next model in the list. For example, `gpt-5.4` will try available providers such as `gpt-5.4@openai` and `gpt-5.4@openrouter` before moving to the next model. Runtime fallback is used for non-retryable provider/model failures such as quota, billing, permission, or model-unavailable errors. `fast_model` is used for session-title generation; `compact_model` is used for compact/helper tasks.
 
 When you switch models with `/model`, Klaude updates `main_model` without discarding the fallback chain: the selected model is moved to the front if it already exists, or inserted at the front otherwise.
 
@@ -171,7 +171,6 @@ When you switch models with `/model`, Klaude updates `main_model` without discar
 | cerebras         | `CEREBRAS_API_KEY`                                                           | glm                                                                                                      |
 | claude-max       | N/A (OAuth)                                             | sonnet, sonnet-no-thinking, opus, haiku                                                                 |
 | codex            | N/A (OAuth)                                                                  | gpt-5.3-codex, gpt-5.3-codex-xhigh, gpt-5.4-high, gpt-5.4-xhigh   |
-| github-copilot   | N/A (OAuth)                                                                  | gpt-5.3-codex, gpt-5.3-codex-xhigh, gpt-5.4-high, gpt-5.4-xhigh, sonnet, sonnet-4.5, haiku, opus       |
 | ark-api          | `ARK_API_KEY`                                                                | seed-pro, seed-code                                                                                      |
 | ark-coding-plan  | `ARK_API_KEY`                                                                | seed-code, kimi                                                                                          |
 
@@ -303,7 +302,6 @@ sub_agent_models:
 - `openai` - OpenAI Chat Completion API
 - `responses` - OpenAI Responses API (for o-series, GPT-5, Codex)
 - `codex_oauth` - OpenAI Codex CLI (OAuth-based, for ChatGPT Pro subscribers)
-- `github_copilot_oauth` - GitHub Copilot (OAuth-based)
 - `openrouter` - OpenRouter API (handling `reasoning_details` for interleaved thinking)
 - `google` - Google Gemini API
 - `google_vertex` - Google Vertex AI (uses GCP credentials)
@@ -347,7 +345,6 @@ Inside the interactive session (`klaude`), use these commands to streamline your
 - `/new` - Start a new session (clears context).
 - `/model` - Switch the active LLM and update `main_model` in config while preserving fallback order (the selected model is moved/inserted to the front).
 - `/sub-agent-model` - Configure sub-agent models at runtime.
-- `/thinking` - Change thinking/reasoning level.
 - `/status` - Show session usage statistics (cost, tokens, model breakdown).
 - `/login` - Login to provider or configure API key.
 - `/logout` - Logout from provider.
@@ -363,7 +360,6 @@ Inside the interactive session (`klaude`), use these commands to streamline your
 | `Shift+Enter`        | Insert newline (terminal-dependent)         |
 | `Ctrl+J`             | Insert newline                              |
 | `Ctrl+L`             | Open model picker overlay                   |
-| `Ctrl+T`             | Open thinking level picker overlay          |
 | `Ctrl+V`             | Paste image from clipboard                  |
 | `Left/Right`         | Move cursor (wraps across lines)            |
 | `Backspace`          | Delete character or selected text           |
@@ -402,13 +398,13 @@ Klaude is designed to maximize prefix cache hit rates across LLM API calls. Cach
 **Append-only message history.** The conversation history is strictly append-only. New messages, tool results, and attachments are always appended to the end of the message array, never inserted or modified in the middle. Any mutation to the head of the messages array (compressing old tool results, replacing images, reordering tool definitions) would invalidate the prefix cache and force a full re-tokenization.
 
 Design choices that preserve prefix stability:
-- **Stable system prompt**: The system prompt is composed of a static base prompt + stable tool strategy block + environment info, avoiding per-turn variation.
+- **Stable system prompt**: The system prompt is composed of a static base prompt + stable tool strategy block + environment info, avoiding per-step variation.
 - **Stable JSON serialization**: Tool schemas and provider payloads use `canonicalize_json()` for deterministic key ordering across calls.
 - **Cache control markers**: For Anthropic and OpenRouter (Claude models), `cache_control: {"type": "ephemeral"}` is placed on the system prompt and the last message part to hint the provider's caching boundary.
 - **Compaction preserves prefix**: When context is compacted, the summary is prepended as a new first message while keeping the retained tail intact -- no existing message bytes are modified.
 - **Fork-context sub-agents**: Sub-agents with `fork_context=True` inherit the parent's full system prompt and tool list to maximize prefix cache sharing.
 
-The TUI displays cache hit rate per turn in the metadata line (e.g. `cache 12.5k (98%)`). Rates below 90% are highlighted as a warning.
+The TUI displays cache hit rate per step in the metadata line (e.g. `cache 12.5k (98%)`). Rates below 90% are highlighted as a warning.
 
 ### Context Management
 

{klaude_code-2.30.0 → klaude_code-2.31.0}/README.md

@@ -125,7 +125,7 @@ compact_model:
   - haiku
 ```
 
-Klaude expands each entry into concrete provider candidates in `provider_list` order, then falls through to the next model in the list. For example, `gpt-5.4` will try available providers such as `gpt-5.4@openai`, `gpt-5.4@github-copilot`, and `gpt-5.4@openrouter` before moving to the next model. Runtime fallback is used for non-retryable provider/model failures such as quota, billing, permission, or model-unavailable errors. `fast_model` is used for session-title generation; `compact_model` is used for compact/helper tasks.
+Klaude expands each entry into concrete provider candidates in `provider_list` order, then falls through to the next model in the list. For example, `gpt-5.4` will try available providers such as `gpt-5.4@openai` and `gpt-5.4@openrouter` before moving to the next model. Runtime fallback is used for non-retryable provider/model failures such as quota, billing, permission, or model-unavailable errors. `fast_model` is used for session-title generation; `compact_model` is used for compact/helper tasks.
 
 When you switch models with `/model`, Klaude updates `main_model` without discarding the fallback chain: the selected model is moved to the front if it already exists, or inserted at the front otherwise.
 
@@ -144,7 +144,6 @@ When you switch models with `/model`, Klaude updates `main_model` without discar
 | cerebras         | `CEREBRAS_API_KEY`                                                           | glm                                                                                                      |
 | claude-max       | N/A (OAuth)                                             | sonnet, sonnet-no-thinking, opus, haiku                                                                 |
 | codex            | N/A (OAuth)                                                                  | gpt-5.3-codex, gpt-5.3-codex-xhigh, gpt-5.4-high, gpt-5.4-xhigh   |
-| github-copilot   | N/A (OAuth)                                                                  | gpt-5.3-codex, gpt-5.3-codex-xhigh, gpt-5.4-high, gpt-5.4-xhigh, sonnet, sonnet-4.5, haiku, opus       |
 | ark-api          | `ARK_API_KEY`                                                                | seed-pro, seed-code                                                                                      |
 | ark-coding-plan  | `ARK_API_KEY`                                                                | seed-code, kimi                                                                                          |
 
@@ -276,7 +275,6 @@ sub_agent_models:
 - `openai` - OpenAI Chat Completion API
 - `responses` - OpenAI Responses API (for o-series, GPT-5, Codex)
 - `codex_oauth` - OpenAI Codex CLI (OAuth-based, for ChatGPT Pro subscribers)
-- `github_copilot_oauth` - GitHub Copilot (OAuth-based)
 - `openrouter` - OpenRouter API (handling `reasoning_details` for interleaved thinking)
 - `google` - Google Gemini API
 - `google_vertex` - Google Vertex AI (uses GCP credentials)
@@ -320,7 +318,6 @@ Inside the interactive session (`klaude`), use these commands to streamline your
 - `/new` - Start a new session (clears context).
 - `/model` - Switch the active LLM and update `main_model` in config while preserving fallback order (the selected model is moved/inserted to the front).
 - `/sub-agent-model` - Configure sub-agent models at runtime.
-- `/thinking` - Change thinking/reasoning level.
 - `/status` - Show session usage statistics (cost, tokens, model breakdown).
 - `/login` - Login to provider or configure API key.
 - `/logout` - Logout from provider.
@@ -336,7 +333,6 @@ Inside the interactive session (`klaude`), use these commands to streamline your
 | `Shift+Enter`        | Insert newline (terminal-dependent)         |
 | `Ctrl+J`             | Insert newline                              |
 | `Ctrl+L`             | Open model picker overlay                   |
-| `Ctrl+T`             | Open thinking level picker overlay          |
 | `Ctrl+V`             | Paste image from clipboard                  |
 | `Left/Right`         | Move cursor (wraps across lines)            |
 | `Backspace`          | Delete character or selected text           |
@@ -375,13 +371,13 @@ Klaude is designed to maximize prefix cache hit rates across LLM API calls. Cach
 **Append-only message history.** The conversation history is strictly append-only. New messages, tool results, and attachments are always appended to the end of the message array, never inserted or modified in the middle. Any mutation to the head of the messages array (compressing old tool results, replacing images, reordering tool definitions) would invalidate the prefix cache and force a full re-tokenization.
 
 Design choices that preserve prefix stability:
-- **Stable system prompt**: The system prompt is composed of a static base prompt + stable tool strategy block + environment info, avoiding per-turn variation.
+- **Stable system prompt**: The system prompt is composed of a static base prompt + stable tool strategy block + environment info, avoiding per-step variation.
 - **Stable JSON serialization**: Tool schemas and provider payloads use `canonicalize_json()` for deterministic key ordering across calls.
 - **Cache control markers**: For Anthropic and OpenRouter (Claude models), `cache_control: {"type": "ephemeral"}` is placed on the system prompt and the last message part to hint the provider's caching boundary.
 - **Compaction preserves prefix**: When context is compacted, the summary is prepended as a new first message while keeping the retained tail intact -- no existing message bytes are modified.
 - **Fork-context sub-agents**: Sub-agents with `fork_context=True` inherit the parent's full system prompt and tool list to maximize prefix cache sharing.
 
-The TUI displays cache hit rate per turn in the metadata line (e.g. `cache 12.5k (98%)`). Rates below 90% are highlighted as a warning.
+The TUI displays cache hit rate per step in the metadata line (e.g. `cache 12.5k (98%)`). Rates below 90% are highlighted as a warning.
 
 ### Context Management
 

{klaude_code-2.30.0 → klaude_code-2.31.0}/pyproject.toml

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

klaude_code-2.31.0/src/klaude_code/agent/__init__.py

@@ -0,0 +1,3 @@
+"""Execution-plane package (agent/task/step/runtime)."""
+
+__all__: list[str] = []

{klaude_code-2.30.0 → klaude_code-2.31.0}/src/klaude_code/agent/agent.py

@@ -38,7 +38,7 @@ class Agent:
         self.profile: AgentProfile = profile
         self.compact_llm_client: LLMClientABC | None = compact_llm_client
         self._current_task: TaskExecutor | None = None
-        self._follow_up_queue: list[UserInputPayload] = [item.model_copy(deep=True) for item in session.follow_up_queue]
+        self._follow_up_queue: list[UserInputPayload] = list(session.follow_up_queue)
         self._last_interrupt_show_notice = True
         self._last_interrupt_prefill_text: str | None = None
         self.request_user_interaction = request_user_interaction
@@ -163,7 +163,9 @@ class Agent:
         self.session.model_name = profile.llm_client.model_name
 
     def _apply_llm_client_change(self, llm_client: LLMClientABC) -> AgentProfile:
-        if self._model_profile_provider is None:
+        if self._model_profile_provider is None or (
+            self.session.sub_agent_state is not None and self.session.sub_agent_state.fork_context
+        ):
             profile = AgentProfile(
                 llm_client=llm_client,
                 system_prompt=self.profile.system_prompt,

{klaude_code-2.30.0 → klaude_code-2.31.0}/src/klaude_code/agent/attachments/files.py

@@ -254,7 +254,7 @@ def _compute_diff_snippet(old_content: str, new_content: str, file_path: str) ->
 
     * If ``old_content + new_content`` already exceeds the source size limit,
       skip ``difflib`` entirely. Large HTML/minified blobs produce diffs that
-      approach ``2x`` the source, which in past sessions pushed the next turn
+      approach ``2x`` the source, which in past sessions pushed the next step
       past the 1M-token ceiling even after a successful compaction.
     * After the diff is built, keep only the first ``ATTACHMENT_DIFF_MAX_LINES``
       lines and append a Read-tool-style notice, mirroring how the Read tool

{klaude_code-2.30.0 → klaude_code-2.31.0}/src/klaude_code/agent/attachments/skills.py

@@ -162,7 +162,7 @@ def _render_skill_inline_content(raw_content: str, skill: Skill) -> str:
 
     The raw content (not the rendered/truncated version) should still be used
     when computing the skill's file-tracker sha256; otherwise a truncated skill
-    would be re-classified as "changed" on every turn.
+    would be re-classified as "changed" on every step.
     """
     truncation = truncate_text_by_lines(raw_content, max_lines=ATTACHMENT_SKILL_MAX_LINES)
     if not truncation.truncated:

{klaude_code-2.30.0 → klaude_code-2.31.0}/src/klaude_code/agent/away_summary.py

@@ -20,7 +20,7 @@ from klaude_code.session.session import Session
 _AWAY_SUMMARY_MAX_TOKENS = 512
 
 # Recap only needs recent context — truncate to avoid "prompt too long" on
-# large sessions. 30 turn messages is plenty for "where we left off."
+# large sessions. 30 recent messages is plenty for "where we left off."
 _RECENT_MESSAGE_WINDOW = 30
 
 
@@ -29,17 +29,17 @@ def _build_away_summary_user_message(transcript: str) -> message.UserMessage:
     return message.UserMessage(parts=[message.TextPart(text=body)])
 
 
-def _recent_turn_messages(session: Session, limit: int) -> list[message.Message]:
-    """Pull the last `limit` turn messages (user/assistant/tool_result)."""
+def _recent_recap_messages(session: Session, limit: int) -> list[message.Message]:
+    """Pull the last `limit` recap messages (user/assistant/tool_result)."""
 
-    turns: list[message.Message] = []
+    messages: list[message.Message] = []
     for item in reversed(session.conversation_history):
         if isinstance(item, (message.UserMessage, message.AssistantMessage, message.ToolResultMessage)):
-            turns.append(item)
-            if len(turns) >= limit:
+            messages.append(item)
+            if len(messages) >= limit:
                 break
-    turns.reverse()
-    return turns
+    messages.reverse()
+    return messages
 
 
 def _normalize_recap(raw: str) -> str | None:
@@ -59,11 +59,11 @@ async def generate_away_summary(
     """Generate a short away-summary text. Returns None on empty session,
     abort, or error — never raises."""
 
-    turns = _recent_turn_messages(session, _RECENT_MESSAGE_WINDOW)
-    if not turns:
+    messages = _recent_recap_messages(session, _RECENT_MESSAGE_WINDOW)
+    if not messages:
         return None
 
-    transcript = serialize_conversation(turns)
+    transcript = serialize_conversation(messages)
     if not transcript.strip():
         return None
 
@@ -75,7 +75,7 @@ async def generate_away_summary(
     call_param.max_tokens = _AWAY_SUMMARY_MAX_TOKENS
     call_param.tools = None
 
-    log_debug("[AwaySummary] request", f"turns={len(turns)}", debug_type=DebugType.RESPONSE)
+    log_debug("[AwaySummary] request", f"messages={len(messages)}", debug_type=DebugType.RESPONSE)
 
     if cancel is not None and cancel.is_set():
         return None

{klaude_code-2.30.0 → klaude_code-2.31.0}/src/klaude_code/agent/cache_break_detection.py

@@ -1,9 +1,9 @@
 """Prompt-prefix cache tracking: hit rate computation and break detection.
 
-Consolidates all cache-related turn-over-turn tracking:
+Consolidates all cache-related step-over-step tracking:
 - Cache hit rate: ``cached_tokens[N] / input_tokens[N-1]``, fed to the spinner.
 - Cache break detection: alerts when cached tokens drop significantly between
-  turns, writes a report file with diagnosis.
+  steps, writes a report file with diagnosis.
 """
 
 from __future__ import annotations
@@ -79,7 +79,7 @@ class CacheBreakReport:
             "Prompt Cache Break Report",
             "========================",
             f"Time: {datetime.now().isoformat()}",
-            f"Turn: #{self.call_number}",
+            f"Step: #{self.call_number}",
             "",
             "## Summary",
             f"Reason: {self.reason}",
@@ -127,15 +127,15 @@ class CacheBreakReport:
 
 
 class CacheTracker:
-    """Tracks prompt-prefix cache across turns.
+    """Tracks prompt-prefix cache across steps.
 
-    Owned by ``MetadataAccumulator``; handles both the per-turn hit rate
+    Owned by ``MetadataAccumulator``; handles both the per-step hit rate
     (for the spinner) and cache-break detection (for the error alert).
     """
 
     def __init__(self) -> None:
         # --- hit rate state ---
-        self._prev_turn_input_tokens: int = 0
+        self._prev_step_input_tokens: int = 0
         self._hit_rate_sum: float = 0.0
         self._hit_rate_count: int = 0
         self.last_hit_rate: float | None = None
@@ -152,13 +152,13 @@ class CacheTracker:
     # -- public: called by MetadataAccumulator ---------------------
 
     @property
-    def prev_turn_input_tokens(self) -> int:
-        """Input token count from the most recent successful turn (for first-token timeout)."""
-        return self._prev_turn_input_tokens
+    def prev_step_input_tokens(self) -> int:
+        """Input token count from the most recent successful step (for first-token timeout)."""
+        return self._prev_step_input_tokens
 
     @property
     def avg_hit_rate(self) -> float | None:
-        """Average cache hit rate across all turns (for task metadata)."""
+        """Average cache hit rate across all steps (for task metadata)."""
         return self._hit_rate_sum / self._hit_rate_count if self._hit_rate_count > 0 else None
 
     def record_pre_call_state(
@@ -180,18 +180,18 @@ class CacheTracker:
         self._call_count += 1
 
     def update(self, usage: Usage) -> CacheBreakReport | None:
-        """Process a turn's usage: compute hit rate and check for cache break.
+        """Process a step's usage: compute hit rate and check for cache break.
 
         Returns a ``CacheBreakReport`` if a break is detected, ``None`` otherwise.
         """
         # --- hit rate ---
-        if self._prev_turn_input_tokens > 0:
-            hit_rate = usage.cached_tokens / self._prev_turn_input_tokens
+        if self._prev_step_input_tokens > 0:
+            hit_rate = usage.cached_tokens / self._prev_step_input_tokens
             self._hit_rate_sum += hit_rate
             self._hit_rate_count += 1
             self.last_hit_rate = hit_rate
             self.last_cached_tokens = usage.cached_tokens
-            self.last_prev_input_tokens = self._prev_turn_input_tokens
+            self.last_prev_input_tokens = self._prev_step_input_tokens
         else:
             self.last_hit_rate = None
             self.last_cached_tokens = 0
@@ -199,7 +199,7 @@ class CacheTracker:
 
         # Use the larger value as denominator baseline so cache hit rate remains
         # stable across providers with different usage field semantics.
-        self._prev_turn_input_tokens = max(
+        self._prev_step_input_tokens = max(
             usage.input_tokens,
             usage.cached_tokens + usage.cache_write_tokens,
         )

{klaude_code-2.30.0 → klaude_code-2.31.0}/src/klaude_code/agent/compaction/AGENTS.md

@@ -45,12 +45,12 @@ if run_ops and should_compact_threshold(...):
     await executor.submit_and_wait(CompactSessionOperation(...))
 ```
 
-### 2. Task Turn Start (`agent/task.py`)
+### 2. Task Step Start (`agent/task.py`)
 
-At the beginning of each turn in `TaskRunner._run_inner()`. Important for multi-turn tool loops where no new user input occurs:
+At the beginning of each step in `TaskRunner._run_inner()`. Important for multi-step tool loops where no new user input occurs:
 
 ```python
-# Threshold-based compaction before starting a new turn
+# Threshold-based compaction before starting a new step
 if ctx.sub_agent_state is None and should_compact_threshold(...):
     result = await run_compaction(reason=CompactionReason.THRESHOLD, ...)
     session_ctx.append_history([result.to_entry()])
@@ -63,11 +63,11 @@ Note: Sub-agents skip threshold compaction (handled by parent).
 When LLM API returns context overflow error, triggers compaction and retries:
 
 ```python
-except TurnError as e:
+except StepError as e:
     if is_context_overflow(str(e)):
         result = await run_compaction(reason=CompactionReason.OVERFLOW, ...)
         session_ctx.append_history([result.to_entry()])
-        continue  # retry turn
+        continue  # retry step
 ```
 
 ## Compaction Process

{klaude_code-2.30.0 → klaude_code-2.31.0}/src/klaude_code/agent/compaction/compaction.py

@@ -22,6 +22,7 @@ from klaude_code.llm import LLMClientABC
 from klaude_code.prompts.compaction import (
     COMPACT_FORK_PROMPT,
     COMPACT_FORK_UPDATE_PROMPT,
+    COMPACTION_CONTINUATION_INSTRUCTION,
     COMPACTION_SUMMARY_PREFIX,
     SUMMARIZATION_PROMPT,
     SUMMARIZATION_SYSTEM_PROMPT,
@@ -36,6 +37,21 @@ _MAX_TOOL_OUTPUT_CHARS = 4000
 _MAX_TOOL_CALL_CHARS = 2000
 _DEFAULT_IMAGE_TOKENS = 1200
 _SYSTEM_REMINDER_RE = re.compile(r"<system-reminder>.*?</system-reminder>", re.DOTALL)
+_CONSTRAINTS_SECTION_RE = re.compile(r"(?ms)^(## Constraints & Preferences\s*\n)(.*?)(?=^## |\Z)")
+_SUMMARY_INSTRUCTION_LEAK_MARKERS = (
+    "不要继续当前任务",
+    "不要继续对话",
+    "只输出结构化上下文摘要",
+    "只输出结构化摘要",
+    "只输出更新后的结构化摘要",
+    "do not continue the task",
+    "do not continue the conversation",
+    "only output the structured summary",
+    "only output the updated structured summary",
+    "tool/continuation/output-format rules",
+)
+_SUMMARY_TOOL_LEAK_MARKERS = ("不要调用任何工具", "不要使用工具", "do not call any tools")
+_SUMMARY_CONTEXT_MARKERS = ("摘要", "summary", "structured", "only output", "只输出")
 
 
 class CompactionReason(str, Enum):
@@ -91,7 +107,7 @@ def _resolve_compaction_config(
             keep_recent = min(keep_recent, max_keep)
     # Manual /compact expresses user intent to aggressively free context, not
     # just bring the session back under the auto threshold. Shrink keep_recent
-    # so roughly the last turn or two stays uncompacted. Guarded by min() so
+    # so roughly the last step or two stays uncompacted. Guarded by min() so
     # tiny sessions (where threshold keep is already small) don't inflate back.
     if reason == CompactionReason.MANUAL:
         keep_recent = min(keep_recent, max(2048, min(8192, keep_recent // 4)))
@@ -202,7 +218,11 @@ async def run_compaction(
     if cut_index <= base_start_index:
         raise ValueError("Nothing to compact (session too small)")
 
-    previous_summary = last_compaction.summary if last_compaction else None
+    previous_summary = (
+        sanitize_summary_instruction_leaks(_strip_trailing_continuation_instruction(last_compaction.summary))
+        if last_compaction
+        else None
+    )
     tokens_before = get_last_context_tokens(session)
     if tokens_before is None:
         tokens_before = estimate_history_tokens(history)
@@ -255,6 +275,8 @@ async def run_compaction(
         )
         fork_usage = None
 
+    summary = sanitize_summary_instruction_leaks(summary)
+
     file_ops = collect_file_operations(
         session=session,
         summarized_messages=messages_to_summarize,
@@ -262,6 +284,7 @@ async def run_compaction(
         previous_details=last_compaction.details if last_compaction else None,
     )
     summary += format_file_operations(file_ops.read_files, file_ops.modified_files)
+    summary = append_continuation_instruction(summary)
 
     kept_items_brief = collect_kept_items_brief(history, cut_index)
 
@@ -498,6 +521,44 @@ def format_file_operations(read_files: list[str], modified_files: list[str]) ->
     return "\n\n" + "\n\n".join(sections)
 
 
+def sanitize_summary_instruction_leaks(summary: str) -> str:
+    """Remove compaction meta-instructions leaked into summary constraints."""
+
+    def _replace(match: re.Match[str]) -> str:
+        header = match.group(1)
+        body = match.group(2)
+        kept_lines = [line for line in body.splitlines() if not _is_summary_instruction_leak(line)]
+        kept_body = "\n".join(kept_lines).strip()
+        if not kept_body:
+            kept_body = "- (none)"
+        return f"{header}{kept_body}\n\n"
+
+    return _CONSTRAINTS_SECTION_RE.sub(_replace, summary)
+
+
+def _is_summary_instruction_leak(line: str) -> bool:
+    normalized = line.strip().lower()
+    if not normalized.startswith(("-", "*")):
+        return False
+    if any(marker in normalized for marker in _SUMMARY_INSTRUCTION_LEAK_MARKERS):
+        return True
+    has_tool_marker = any(marker in normalized for marker in _SUMMARY_TOOL_LEAK_MARKERS)
+    has_summary_context = any(marker in normalized for marker in _SUMMARY_CONTEXT_MARKERS)
+    return has_tool_marker and has_summary_context
+
+
+def append_continuation_instruction(summary: str) -> str:
+    base = _strip_trailing_continuation_instruction(summary).rstrip()
+    return f"{base}\n\n{COMPACTION_CONTINUATION_INSTRUCTION}"
+
+
+def _strip_trailing_continuation_instruction(summary: str) -> str:
+    stripped = summary.rstrip()
+    if stripped.endswith(COMPACTION_CONTINUATION_INSTRUCTION):
+        return stripped[: -len(COMPACTION_CONTINUATION_INSTRUCTION)].rstrip()
+    return summary
+
+
 def _find_last_compaction(
     history: list[message.HistoryEvent],
 ) -> tuple[int, message.CompactionEntry | None]:
@@ -566,10 +627,10 @@ def _adjust_cut_index(history: list[message.HistoryEvent], cut_index: int, start
     # kept together. This protects get_llm_history's _strip_dangling_tool_calls from
     # fabricating synthetic "interrupted" messages (which also breaks cache prefix
     # match with the parent request).
-    return _avoid_splitting_tool_turn(history, cut_index, start_index)
+    return _avoid_splitting_tool_step(history, cut_index, start_index)
 
 
-def _avoid_splitting_tool_turn(history: list[message.HistoryEvent], cut_index: int, start_index: int) -> int:
+def _avoid_splitting_tool_step(history: list[message.HistoryEvent], cut_index: int, start_index: int) -> int:
     """Walk compacted backwards; if the most recent Assistant has dangling tool_calls,
     move cut_index to before that Assistant.
     """
@@ -604,7 +665,7 @@ def _find_anchor_index(history: list[message.HistoryEvent], start: int, *, forwa
     DeveloperMessage is skipped because this search is invoked precisely to escape
     a DeveloperMessage cut position.
 
-    The final ``_avoid_splitting_tool_turn`` pass catches the remaining unsafe
+    The final ``_avoid_splitting_tool_step`` pass catches the remaining unsafe
     case: cut landing immediately before an Assistant whose tool_calls have
     results in compacted (rare, only via backward anchor).
     """

{klaude_code-2.30.0 → klaude_code-2.31.0}/src/klaude_code/agent/handoff/handoff.py

@@ -22,7 +22,7 @@ from klaude_code.agent.compaction.compaction import (
 )
 from klaude_code.const import (
     INITIAL_RETRY_DELAY_S,
-    MAX_FAILED_TURN_RETRIES,
+    MAX_FAILED_STEP_RETRIES,
     MAX_RETRY_DELAY_S,
 )
 from klaude_code.llm import LLMClientABC
@@ -220,7 +220,7 @@ async def _call_extractor(
     if cancel is not None and cancel.is_set():
         raise asyncio.CancelledError
 
-    for attempt in range(MAX_FAILED_TURN_RETRIES + 1):
+    for attempt in range(MAX_FAILED_STEP_RETRIES + 1):
         try:
             return await _call_extractor_once(
                 input=input,
@@ -231,7 +231,7 @@ async def _call_extractor(
         except asyncio.CancelledError:
             raise
         except Exception:
-            if attempt >= MAX_FAILED_TURN_RETRIES:
+            if attempt >= MAX_FAILED_STEP_RETRIES:
                 raise
             delay = _retry_delay_seconds(attempt + 1)
             if cancel is None:

{klaude_code-2.30.0 → klaude_code-2.31.0}/src/klaude_code/agent/prompt_suggestion/prompt_suggestion.py

@@ -1,9 +1,9 @@
-"""Prompt-suggestion generator (forked LLM query, cache-shared with main turn).
+"""Prompt-suggestion generator (forked LLM query, cache-shared with main step).
 
 After every task finishes, predict what the user might naturally type next.
-Mirrors claude-code's promptSuggestion service: short single-turn LLM call
+Mirrors claude-code's promptSuggestion service: short single-step LLM call
 with the main profile's system/tools/model/thinking, so the wire prefix
-equals the parent turn's wire prefix and cache read hits ~100%.
+equals the parent step's wire prefix and cache read hits ~100%.
 
 The model is instructed to reply with exactly ``[DONE]`` when it has nothing
 worth suggesting; we filter that plus a small set of low-quality patterns
@@ -73,7 +73,7 @@ def should_suggest(session: Session) -> str | None:
     usage = last_assistant.usage
     if usage is not None:
         # Cache-cold budget, matching claude-code's getParentCacheSuppressReason:
-        # skip when the parent turn had to do a lot of fresh (un-cached) work,
+        # skip when the parent step had to do a lot of fresh (un-cached) work,
         # because the fork inherits similar cost.
         total_input = _normalized_total_input_tokens(usage)
         uncached = max(0, total_input - usage.cached_tokens) + usage.output_tokens

{klaude_code-2.30.0 → klaude_code-2.31.0}/src/klaude_code/agent/runtime/agent_ops.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 import contextlib
+import traceback
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 from pathlib import Path
@@ -112,7 +113,6 @@ class AgentOperationHandler:
         allowed_sources: set[user_interaction.UserInteractionSource] = {
             "tool",
             "operation_model",
-            "operation_thinking",
             "operation_sub_agent_model",
         }
         if source not in allowed_sources:
@@ -974,8 +974,6 @@ class AgentOperationHandler:
             await self._emit_event(events.TaskFinishEvent(session_id=session_id, task_result="task cancelled"))
 
         except Exception as e:
-            import traceback
-
             log_debug(
                 f"Agent task {task_id} failed: {e!s}",
                 debug_type=DebugType.EXECUTION,
@@ -1080,8 +1078,6 @@ class AgentOperationHandler:
             )
             raise
         except Exception as exc:
-            import traceback
-
             log_debug(
                 f"[Compact:{reason}] error",
                 str(exc.__class__.__name__),

{klaude_code-2.30.0 → klaude_code-2.31.0}/src/klaude_code/agent/runtime/away_summary.py

@@ -2,7 +2,7 @@
 
 The recap is auto-triggered only when all of the following are true:
 
-- A task/turn finished.
+- A task finished.
 - The TUI is back at the prompt.
 - The user has not pressed any keys since that task finished.
 - The prompt stayed idle for the configured delay.