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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 2.29.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.29.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.29.0 → klaude_code-2.31.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "2.29.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.29.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.29.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.29.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.29.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.29.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.29.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.29.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)
@@ -214,6 +234,7 @@ async def run_compaction(
         summary, fork_usage = await _build_summary_fork(
             session=session,
             cut_index=cut_index,
+            llm_client=llm_client,
             main_profile=main_profile,
             focus=focus,
             has_previous_summary=previous_summary is not None,
@@ -254,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,
@@ -261,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)
 
@@ -285,6 +309,7 @@ async def _build_summary_fork(
     *,
     session: Session,
     cut_index: int,
+    llm_client: LLMClientABC,
     main_profile: AgentProfile,
     focus: str | None,
     has_previous_summary: bool,
@@ -321,7 +346,7 @@ async def _build_summary_fork(
     call_param.tools = main_profile.tools  # Must match parent; tools=[] would break cache.
     call_param.max_tokens = max_summary_tokens
 
-    stream = await main_profile.llm_client.call(call_param)
+    stream = await llm_client.call(call_param)
     accumulated: list[str] = []
     final_message: message.AssistantMessage | None = None
     async for item in stream:
@@ -496,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]:
@@ -564,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.
     """
@@ -602,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.29.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.31.0/src/klaude_code/agent/model_fallback.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from klaude_code.agent.compaction.overflow import is_context_overflow
+from klaude_code.agent.runtime.llm import FallbackLLMClient, ModelFallback
+from klaude_code.llm import LLMClientABC
+from klaude_code.protocol import events, message
+from klaude_code.protocol.tools import SubAgentType
+
+
+def fallback_reason(error_message: str) -> str:
+    first_line = error_message.strip().splitlines()[0] if error_message.strip() else "LLM request failed"
+    return first_line[:500]
+
+
+def is_fallbackable_llm_error(error_message: str) -> bool:
+    text = error_message.casefold()
+    if is_context_overflow(error_message):
+        return False
+    fallbackable_markers = (
+        "insufficient_quota",
+        "exceeded your current quota",
+        "quota exceeded",
+        "quota_exceeded",
+        "billing",
+        "credit balance",
+        "credits exhausted",
+        "insufficient credits",
+        "payment required",
+        "model_not_found",
+        "model_not_available",
+        "does not have access to model",
+        "not authorized to access",
+        "permission_denied",
+        "permission denied",
+        "usage_limit_reached",
+    )
+    return any(marker in text for marker in fallbackable_markers)
+
+
+def fallback_llm_client(client: LLMClientABC, error_message: str) -> ModelFallback | None:
+    if not isinstance(client, FallbackLLMClient):
+        return None
+    if not is_fallbackable_llm_error(error_message):
+        return None
+    return client.fallback_to_next()
+
+
+def build_fallback_model_config_warn(
+    *,
+    session_id: str,
+    fallback: ModelFallback,
+    error_message: str,
+    sub_agent_type: SubAgentType | None = None,
+) -> tuple[message.FallbackModelConfigWarnEntry, events.FallbackModelConfigWarnEvent]:
+    reason = fallback_reason(error_message)
+    entry = message.FallbackModelConfigWarnEntry(
+        sub_agent_type=sub_agent_type,
+        from_model=fallback.from_candidate.model_name,
+        from_provider=fallback.from_candidate.provider,
+        to_model=fallback.to_candidate.model_name,
+        to_provider=fallback.to_candidate.provider,
+        reason=reason,
+    )
+    event = events.FallbackModelConfigWarnEvent(
+        session_id=session_id,
+        sub_agent_type=entry.sub_agent_type,
+        from_model=entry.from_model,
+        from_provider=entry.from_provider,
+        to_model=entry.to_model,
+        to_provider=entry.to_provider,
+        reason=entry.reason,
+    )
+    return entry, event