klaude-code 2.26.0__tar.gz → 2.28.0__tar.gz

{klaude_code-2.26.0 → klaude_code-2.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 2.26.0
+Version: 2.28.0
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic[bedrock]>=0.66.0
 Requires-Dist: chardet>=5.2.0,<6
@@ -20,6 +20,7 @@ Requires-Dist: trafilatura>=2.0.0
 Requires-Dist: typer>=0.17.3
 Requires-Dist: uvicorn
 Requires-Dist: readability-lxml>=0.8.4.1
+Requires-Dist: pillow>=12.2.0
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 
@@ -132,9 +133,14 @@ klaude
 
 On first run, you'll be prompted to select a model. Your choice is saved as `main_model`.
 
-You can also configure fallback lists for helper models:
+You can also configure fallback lists for the main model and helper models:
 
 ```yaml
+main_model:
+  - gpt-5.5
+  - gpt-5.4
+  - opus
+
 fast_model:
   - haiku
   - gemini-flash
@@ -145,7 +151,9 @@ compact_model:
   - haiku
 ```
 
-Klaude tries these entries in order and uses the first available model. `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`, `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.
+
+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.
 
 #### Built-in Providers
 
@@ -221,7 +229,10 @@ You can add custom models to built-in providers or define new ones. Configuratio
 
 ```yaml
 # ~/.klaude/klaude-config.yaml
-main_model: opus
+main_model:
+  - gpt-5.5
+  - gpt-5.4
+  - opus
 
 fast_model:
   - haiku
@@ -261,7 +272,8 @@ provider_list:
 - **Merging**: If `provider_name` matches a built-in provider, settings like `protocol` and `api_key` are inherited.
 - **Overriding**: Use the same `model_name` as a built-in model to override its parameters.
 - **Environment Variables**: Use `${VAR_NAME}` syntax for secrets.
-- **Model Preference Lists**: `fast_model` and `compact_model` accept either a single string or a list of model selectors. When you provide a list, Klaude tries them in order and picks the first available one.
+- **Model Preference Lists**: `main_model`, `fast_model`, and `compact_model` accept either a single string or a list of model selectors. When you provide a list, Klaude first tries matching providers in `provider_list` order for each selector, then moves to the next selector.
+- **Updating Defaults**: `/model` keeps saving the selected model back to `main_model`, but preserves fallback order by moving or inserting the selected model at the front of the list.
 
 ##### Sub-agent Model Configuration
 
@@ -332,7 +344,7 @@ Inside the interactive session (`klaude`), use these commands to streamline your
 - `/refresh-terminal` - Refresh terminal display.
 - `/web` - Switch to web UI mode.
 - `/new` - Start a new session (clears context).
-- `/model` - Switch the active LLM during the session.
+- `/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).

{klaude_code-2.26.0 → klaude_code-2.28.0}/README.md

@@ -107,9 +107,14 @@ klaude
 
 On first run, you'll be prompted to select a model. Your choice is saved as `main_model`.
 
-You can also configure fallback lists for helper models:
+You can also configure fallback lists for the main model and helper models:
 
 ```yaml
+main_model:
+  - gpt-5.5
+  - gpt-5.4
+  - opus
+
 fast_model:
   - haiku
   - gemini-flash
@@ -120,7 +125,9 @@ compact_model:
   - haiku
 ```
 
-Klaude tries these entries in order and uses the first available model. `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`, `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.
+
+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.
 
 #### Built-in Providers
 
@@ -196,7 +203,10 @@ You can add custom models to built-in providers or define new ones. Configuratio
 
 ```yaml
 # ~/.klaude/klaude-config.yaml
-main_model: opus
+main_model:
+  - gpt-5.5
+  - gpt-5.4
+  - opus
 
 fast_model:
   - haiku
@@ -236,7 +246,8 @@ provider_list:
 - **Merging**: If `provider_name` matches a built-in provider, settings like `protocol` and `api_key` are inherited.
 - **Overriding**: Use the same `model_name` as a built-in model to override its parameters.
 - **Environment Variables**: Use `${VAR_NAME}` syntax for secrets.
-- **Model Preference Lists**: `fast_model` and `compact_model` accept either a single string or a list of model selectors. When you provide a list, Klaude tries them in order and picks the first available one.
+- **Model Preference Lists**: `main_model`, `fast_model`, and `compact_model` accept either a single string or a list of model selectors. When you provide a list, Klaude first tries matching providers in `provider_list` order for each selector, then moves to the next selector.
+- **Updating Defaults**: `/model` keeps saving the selected model back to `main_model`, but preserves fallback order by moving or inserting the selected model at the front of the list.
 
 ##### Sub-agent Model Configuration
 
@@ -307,7 +318,7 @@ Inside the interactive session (`klaude`), use these commands to streamline your
 - `/refresh-terminal` - Refresh terminal display.
 - `/web` - Switch to web UI mode.
 - `/new` - Start a new session (clears context).
-- `/model` - Switch the active LLM during the session.
+- `/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).

{klaude_code-2.26.0 → klaude_code-2.28.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "2.26.0"
+version = "2.28.0"
 description = "Minimal code agent CLI"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -27,6 +27,7 @@ dependencies = [
     "typer>=0.17.3",
     "uvicorn",
     "readability-lxml>=0.8.4.1",
+    "pillow>=12.2.0",
 ]
 
 [project.scripts]

{klaude_code-2.26.0 → klaude_code-2.28.0}/src/klaude_code/agent/agent.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from collections.abc import AsyncGenerator, Awaitable, Callable, Iterable
 
-from klaude_code.agent.agent_profile import AgentProfile
+from klaude_code.agent.agent_profile import AgentProfile, ModelProfileProvider
 from klaude_code.agent.task import SessionContext, TaskExecutionContext, TaskExecutor
 from klaude_code.llm import LLMClientABC
 from klaude_code.log import DebugType, log_debug
@@ -32,6 +32,7 @@ class Agent:
             ]
             | None
         ) = None,
+        model_profile_provider: ModelProfileProvider | None = None,
     ):
         self.session: Session = session
         self.profile: AgentProfile = profile
@@ -40,6 +41,7 @@ class Agent:
         self._last_interrupt_show_notice = True
         self._last_interrupt_prefill_text: str | None = None
         self.request_user_interaction = request_user_interaction
+        self._model_profile_provider = model_profile_provider
         if not self.session.model_name:
             self.session.model_name = profile.llm_client.model_name
 
@@ -98,6 +100,7 @@ class Agent:
             tool_registry=tool_registry,
             sub_agent_state=self.session.sub_agent_state,
             compact_llm_client=self.compact_llm_client,
+            apply_llm_client_change=self._apply_llm_client_change,
         )
 
         task = TaskExecutor(context)
@@ -127,6 +130,26 @@ class Agent:
         self.profile = profile
         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:
+            profile = AgentProfile(
+                llm_client=llm_client,
+                system_prompt=self.profile.system_prompt,
+                tools=self.profile.tools,
+                attachments=self.profile.attachments,
+            )
+        else:
+            sub_agent_type = None
+            if self.session.sub_agent_state is not None and not self.session.sub_agent_state.fork_context:
+                sub_agent_type = self.session.sub_agent_state.sub_agent_type
+            profile = self._model_profile_provider.build_profile(
+                llm_client,
+                sub_agent_type,
+                work_dir=self.session.work_dir,
+            )
+        self.set_model_profile(profile)
+        return profile
+
     def get_llm_client(self) -> LLMClientABC:
         return self.profile.llm_client
 

klaude_code-2.28.0/src/klaude_code/agent/attachments/__init__.py

@@ -0,0 +1,46 @@
+"""Agent attachment package.
+
+Shared helpers for <system-reminder> content produced by attachments live here.
+Each concrete attachment (files, memory, skills, …) is responsible for
+truncating its own output; these helpers provide a consistent Read-tool-style
+notice so the agent always knows how to fetch the full content.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class LineTruncationResult:
+    """Outcome of :func:`truncate_text_by_lines`."""
+
+    text: str
+    total_lines: int
+    kept_lines: int
+    truncated: bool
+
+    @property
+    def hidden_lines(self) -> int:
+        return max(0, self.total_lines - self.kept_lines)
+
+
+def truncate_text_by_lines(text: str, *, max_lines: int) -> LineTruncationResult:
+    """Keep the first ``max_lines`` lines; report total/hidden line counts.
+
+    The trailing newline (if any) is preserved only when the text was not
+    truncated, matching Read tool behaviour where a truncated view never
+    ends with a bare newline before the notice.
+    """
+    if max_lines <= 0:
+        return LineTruncationResult(
+            text="", total_lines=text.count("\n") + (1 if text else 0), kept_lines=0, truncated=bool(text)
+        )
+
+    lines = text.splitlines()
+    total = len(lines)
+    if total <= max_lines:
+        return LineTruncationResult(text=text, total_lines=total, kept_lines=total, truncated=False)
+
+    kept = "\n".join(lines[:max_lines])
+    return LineTruncationResult(text=kept, total_lines=total, kept_lines=max_lines, truncated=True)

{klaude_code-2.26.0 → klaude_code-2.28.0}/src/klaude_code/agent/attachments/files.py

@@ -5,8 +5,11 @@ import re
 import shlex
 from pathlib import Path
 
+from klaude_code.const import ATTACHMENT_DIFF_MAX_LINES, ATTACHMENT_DIFF_SOURCE_MAX_BYTES
 from klaude_code.prompts.attachments import (
     FILE_ALREADY_IN_CONTEXT_TEMPLATE,
+    FILE_CHANGED_DIFF_SKIPPED_TEMPLATE,
+    FILE_CHANGED_DIFF_TRUNCATED_TEMPLATE,
     FILE_CHANGED_EXTERNALLY_TEMPLATE,
     PASTE_FILE_HINT_TEMPLATE,
     TOOL_RESULT_TEMPLATE,
@@ -28,6 +31,7 @@ from klaude_code.session import Session
 from klaude_code.skill.loader import discover_skills_near_paths
 from klaude_code.tool import BashTool, ReadTool
 
+from . import truncate_text_by_lines
 from .memory import Memory, discover_memory_files_near_paths, format_memory_content
 from .skills import build_dynamic_skill_listing_attachment
 from .state import (
@@ -120,7 +124,7 @@ async def _load_at_file(
     ref: AtFileRef,
     at_ops: list[AtFileOp],
     formatted_blocks: list[str],
-    collected_images: list[message.ImageURLPart],
+    collected_images: list[message.ImageURLPart | message.ImageFilePart],
     collected_image_paths: list[str],
     discovered_memories: list[Memory],
     skill_discovery_paths: list[str],
@@ -141,7 +145,7 @@ async def _load_at_file(
             limit = ref.line_end - ref.line_start + 1
         args = ReadTool.ReadArguments(file_path=path_str, offset=offset, limit=limit)
         tool_result = await ReadTool.call_with_args(args, tool_context)
-        images = [part for part in tool_result.parts if isinstance(part, message.ImageURLPart)]
+        images = [part for part in tool_result.parts if isinstance(part, (message.ImageURLPart, message.ImageFilePart))]
 
         formatted_blocks.append(
             _fmt_tool_result(tools.READ, args.model_dump_json(exclude_none=True), tool_result.output_text)
@@ -210,7 +214,7 @@ async def at_file_reader_attachment(session: Session) -> message.DeveloperMessag
 
     at_ops: list[AtFileOp] = []
     formatted_blocks: list[str] = []
-    collected_images: list[message.ImageURLPart] = []
+    collected_images: list[message.ImageURLPart | message.ImageFilePart] = []
     collected_image_paths: list[str] = []
     discovered_memories: list[Memory] = []
     skill_discovery_paths: list[str] = []
@@ -254,7 +258,27 @@ async def at_file_reader_attachment(session: Session) -> message.DeveloperMessag
     )
 
 
-def _compute_diff_snippet(old_content: str, new_content: str) -> str:
+def _compute_diff_snippet(old_content: str, new_content: str, file_path: str) -> str:
+    """Render a small unified-style diff, capped so it cannot blow up context.
+
+    Guards (see ``const.ATTACHMENT_DIFF_*``):
+
+    * 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
+      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
+      truncates long files.
+    """
+    combined_size_bytes = len(old_content.encode("utf-8")) + len(new_content.encode("utf-8"))
+    if combined_size_bytes > ATTACHMENT_DIFF_SOURCE_MAX_BYTES:
+        return FILE_CHANGED_DIFF_SKIPPED_TEMPLATE.format(
+            total_bytes=combined_size_bytes,
+            limit_bytes=ATTACHMENT_DIFF_SOURCE_MAX_BYTES,
+            file_path=file_path,
+        )
+
     old_lines = old_content.splitlines(keepends=True)
     new_lines = new_content.splitlines(keepends=True)
 
@@ -280,7 +304,15 @@ def _compute_diff_snippet(old_content: str, new_content: str) -> str:
                     diff_lines.append(f"  {line_no:>6}+\t{line.rstrip()}")
         diff_lines.append("  ------")
 
-    return "\n".join(diff_lines).rstrip("\n -")
+    rendered = "\n".join(diff_lines).rstrip("\n -")
+    truncation = truncate_text_by_lines(rendered, max_lines=ATTACHMENT_DIFF_MAX_LINES)
+    if truncation.truncated:
+        return truncation.text + FILE_CHANGED_DIFF_TRUNCATED_TEMPLATE.format(
+            hidden_lines=truncation.hidden_lines,
+            total_lines=truncation.total_lines,
+            file_path=file_path,
+        )
+    return truncation.text
 
 
 async def file_changed_externally_attachment(session: Session) -> message.DeveloperMessage | None:
@@ -316,7 +348,7 @@ async def file_changed_externally_attachment(session: Session) -> message.Develo
             if new_status is None or new_status.cached_content is None:
                 continue
 
-            snippet = _compute_diff_snippet(old_content, new_status.cached_content)
+            snippet = _compute_diff_snippet(old_content, new_status.cached_content, path)
             if not snippet:
                 continue
             changed_files.append((path, snippet))
@@ -377,7 +409,15 @@ async def paste_file_attachment(session: Session) -> message.DeveloperMessage |
     for item in reversed(session.conversation_history):
         if isinstance(item, message.ToolResultMessage):
             return None
-        if isinstance(item, message.UserMessage) and item.pasted_files:
+        if (
+            isinstance(item, message.DeveloperMessage)
+            and item.ui_extra is not None
+            and any(isinstance(ui_item, PasteFilesUIItem) for ui_item in item.ui_extra.items)
+        ):
+            return None
+        if isinstance(item, message.UserMessage):
+            if not item.pasted_files:
+                return None
             return message.DeveloperMessage(
                 parts=message.text_parts_from_str(
                     f"<system-reminder>{_fmt_paste_file_hint(item.pasted_files)}\n</system-reminder>"

{klaude_code-2.26.0 → klaude_code-2.28.0}/src/klaude_code/agent/attachments/memory.py

@@ -5,11 +5,18 @@ from pathlib import Path
 
 from pydantic import BaseModel
 
-from klaude_code.const import ProjectPaths, find_git_repo_root, project_key_from_path
+from klaude_code.const import (
+    ATTACHMENT_MEMORY_MAX_BYTES_PER_FILE,
+    ATTACHMENT_MEMORY_MAX_LINES,
+    ProjectPaths,
+    find_git_repo_root,
+    project_key_from_path,
+)
 from klaude_code.prompts.attachments import (
     AUTO_MEMORY_HINT_TEMPLATE,
     AUTO_MEMORY_INSTRUCTION,
     DISCOVERED_MEMORY_INSTRUCTION,
+    MEMORY_FILE_BYTE_TRUNCATED_TEMPLATE,
     MEMORY_FILE_TRUNCATED_TEMPLATE,
     MEMORY_HEADER,
     MEMORY_TRUNCATED_TEMPLATE,
@@ -20,13 +27,16 @@ from klaude_code.protocol import message
 from klaude_code.protocol.models import DeveloperUIExtra, DeveloperUIItem, MemoryFileLoaded, MemoryLoadedUIItem
 from klaude_code.session import Session
 
+from . import truncate_text_by_lines
 from .state import is_memory_loaded, mark_memory_loaded
 
 MEMORY_FILE_NAMES = ["AGENTS.md", "CLAUDE.md", "AGENT.md"]
 
 AUTO_MEMORY_FILE = "MEMORY.md"
-AUTO_MEMORY_MAX_LINES = 200
-MEMORY_MAX_BYTES_PER_FILE = 4096
+# Kept as module-level aliases for backwards compatibility with existing tests
+# and callers. See src/klaude_code/const.py for the canonical values.
+AUTO_MEMORY_MAX_LINES = ATTACHMENT_MEMORY_MAX_LINES
+MEMORY_MAX_BYTES_PER_FILE = ATTACHMENT_MEMORY_MAX_BYTES_PER_FILE
 MEMORY_MAX_SESSION_BYTES = 60 * 1024
 
 
@@ -131,23 +141,31 @@ def format_memories_attachment(memories: list[Memory], include_header: bool = Tr
 
 
 def truncate_memory_content(text: str, path: str) -> str:
-    """Truncate memory content to the shared per-file limits used by attachments."""
+    """Truncate memory content to the first :data:`AUTO_MEMORY_MAX_LINES` lines.
 
-    lines = text.splitlines()
-    truncated = False
+    Mirrors Read tool behaviour: show a bounded prefix and tell the agent how
+    to fetch the rest. A generous byte cap still applies as a last-resort
+    guard against pathologically long single lines (e.g. minified JSON).
+    """
+    truncation = truncate_text_by_lines(text, max_lines=AUTO_MEMORY_MAX_LINES)
+    result = truncation.text
 
-    if len(lines) > AUTO_MEMORY_MAX_LINES:
-        lines = lines[:AUTO_MEMORY_MAX_LINES]
-        truncated = True
-
-    result = "\n".join(lines)
     if len(result.encode("utf-8")) > MEMORY_MAX_BYTES_PER_FILE:
         encoded = result.encode("utf-8")[:MEMORY_MAX_BYTES_PER_FILE]
         result = encoded.decode("utf-8", errors="ignore")
-        truncated = True
-
-    if truncated:
-        result += MEMORY_FILE_TRUNCATED_TEMPLATE.format(max_bytes=MEMORY_MAX_BYTES_PER_FILE, path=path)
+        total_lines = truncation.total_lines or len(text.splitlines())
+        return result + MEMORY_FILE_BYTE_TRUNCATED_TEMPLATE.format(
+            max_bytes=MEMORY_MAX_BYTES_PER_FILE,
+            total_lines=total_lines,
+            path=path,
+        )
+
+    if truncation.truncated:
+        return result + MEMORY_FILE_TRUNCATED_TEMPLATE.format(
+            max_lines=AUTO_MEMORY_MAX_LINES,
+            total_lines=truncation.total_lines,
+            path=path,
+        )
     return result
 
 

{klaude_code-2.26.0 → klaude_code-2.28.0}/src/klaude_code/agent/attachments/skills.py

@@ -6,15 +6,18 @@ from collections.abc import Callable, Sequence
 from pathlib import Path
 from typing import Literal, cast
 
+from klaude_code.const import ATTACHMENT_SKILL_MAX_LINES
 from klaude_code.prompts.attachments import (
     AVAILABLE_SKILLS_ADDED_TEMPLATE,
     AVAILABLE_SKILLS_TEMPLATE,
     DYNAMIC_AVAILABLE_SKILLS_TEMPLATE,
+    SKILL_ALREADY_IN_CONTEXT_TEMPLATE,
     SKILL_BLOCK_TEMPLATE,
+    SKILL_CONTENT_TRUNCATED_TEMPLATE,
     SKILL_DISCOVERED_PREFACE_TEMPLATE,
     SKILL_EXPLICIT_PREFACE_TEMPLATE,
 )
-from klaude_code.protocol import message
+from klaude_code.protocol import message, tools
 from klaude_code.protocol.models import (
     DeveloperUIExtra,
     DeveloperUIItem,
@@ -33,6 +36,7 @@ from klaude_code.skill.loader import (
 from klaude_code.skill.system_skills import install_system_skills
 from klaude_code.tool.file._utils import hash_text_sha256
 
+from . import truncate_text_by_lines
 from .state import is_tracked_file_unchanged
 
 # Match /skill:xxx or //skill:xxx inline (at start of line or after whitespace).
@@ -73,6 +77,14 @@ def _fmt_available_skills_added(skills_xml: str) -> str:
     return AVAILABLE_SKILLS_ADDED_TEMPLATE.format(skills_xml=skills_xml)
 
 
+def _fmt_skill_already_in_context(skill_name: str, path: str, read_tool_name: str) -> str:
+    return SKILL_ALREADY_IN_CONTEXT_TEMPLATE.format(
+        skill_name=skill_name,
+        path=path,
+        read_tool_name=read_tool_name,
+    )
+
+
 def get_skills_from_user_input(session: Session) -> list[str]:
     for item in reversed(session.conversation_history):
         if isinstance(item, message.ToolResultMessage):
@@ -141,6 +153,27 @@ def _read_skill_content(skill: Skill) -> str | None:
     return content or None
 
 
+def _render_skill_inline_content(raw_content: str, skill: Skill) -> str:
+    """Cap inlined SKILL.md for the <system-reminder> block.
+
+    Mirrors Read tool behaviour: keep the first ``ATTACHMENT_SKILL_MAX_LINES``
+    lines and tell the agent how to fetch the rest. Returning the raw content
+    unchanged when it fits preserves the existing behaviour for small skills.
+
+    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.
+    """
+    truncation = truncate_text_by_lines(raw_content, max_lines=ATTACHMENT_SKILL_MAX_LINES)
+    if not truncation.truncated:
+        return truncation.text
+    return truncation.text + SKILL_CONTENT_TRUNCATED_TEMPLATE.format(
+        max_lines=ATTACHMENT_SKILL_MAX_LINES,
+        total_lines=truncation.total_lines,
+        path=str(skill.skill_path),
+    )
+
+
 def _mark_skill_loaded(session: Session, path: str, content: str, *, source: Literal["dynamic", "explicit"]) -> None:
     existing = session.file_tracker.get(path)
     try:
@@ -150,6 +183,7 @@ def _mark_skill_loaded(session: Session, path: str, content: str, *, source: Lit
     session.file_tracker[path] = FileStatus(
         mtime=mtime,
         content_sha256=hash_text_sha256(content),
+        cached_content=existing.cached_content if existing else None,
         is_memory=existing.is_memory if existing else False,
         is_skill=True,
         is_skill_listing=existing.is_skill_listing if existing else False,
@@ -179,11 +213,20 @@ def _format_skill_block_str(skill: Skill, skill_content: str, *, explicit: bool)
         skill_name=skill.name,
         skill_path=skill.skill_path,
         base_dir=skill.base_dir,
-        skill_content=skill_content,
+        skill_content=_render_skill_inline_content(skill_content, skill),
         explicit=explicit,
     )
 
 
+def _is_skill_content_already_in_context(session: Session, path: str) -> bool:
+    status = session.file_tracker.get(path)
+    if status is None:
+        return False
+    if not status.read_complete and status.skill_attachment_source != "explicit":
+        return False
+    return is_tracked_file_unchanged(session, path)
+
+
 def _build_skills_xml(skills: Sequence[Skill]) -> str:
     loader = SkillLoader()
     loader.loaded_skills = {skill.name: skill for skill in _sort_skills_for_listing(skills)}
@@ -312,6 +355,14 @@ def _collect_skill_blocks(session: Session, skills: list[Skill], *, explicit: bo
             continue
 
         skill_path = str(skill.skill_path)
+        if explicit and _is_skill_content_already_in_context(session, skill_path):
+            _mark_skill_loaded(session, skill_path, skill_content, source="explicit")
+            loaded_dynamic_paths_by_name[skill.name] = skill_path
+            loaded_all_paths_by_name[skill.name] = skill_path
+            skill_blocks.append(_fmt_skill_already_in_context(skill.name, skill_path, tools.READ))
+            activated_skills.append(skill)
+            continue
+
         if not explicit:
             non_dynamic_path = loaded_all_paths_by_name.get(skill.name)
             dynamic_path = loaded_dynamic_paths_by_name.get(skill.name)

{klaude_code-2.26.0 → klaude_code-2.28.0}/src/klaude_code/agent/attachments/state.py

@@ -72,6 +72,18 @@ def mark_directory_accessed(session: Session, path: str) -> None:
     )
 
 
+def reset_attachment_loaded_flags(file_tracker: dict[str, FileStatus]) -> None:
+    """Remove attachment-only entries so transient reminders can re-inject after compaction."""
+
+    transient_paths = [
+        path
+        for path, status in file_tracker.items()
+        if status.is_memory or status.is_skill_listing or status.skill_attachment_source == "dynamic"
+    ]
+    for path in transient_paths:
+        del file_tracker[path]
+
+
 def is_memory_loaded(session: Session, path: str) -> bool:
     """Check if a memory file has already been loaded or read unchanged."""
 

{klaude_code-2.26.0 → klaude_code-2.28.0}/src/klaude_code/agent/away_summary.py

@@ -13,21 +13,10 @@ import re
 from klaude_code.agent.compaction.compaction import serialize_conversation
 from klaude_code.llm.client import LLMClientABC
 from klaude_code.log import DebugType, log_debug
+from klaude_code.prompts.away_summary import AWAY_SUMMARY_SYSTEM_PROMPT, AWAY_SUMMARY_USER_PROMPT
 from klaude_code.protocol import llm_param, message
 from klaude_code.session.session import Session
 
-_AWAY_SUMMARY_SYSTEM_PROMPT = (
-    "You summarize an in-progress coding session for a user who stepped away. "
-    "Write a neutral recap, not an evaluation. Do not praise, judge, agree "
-    "with, or endorse any proposal. Do not speak in first person as the "
-    "assistant, and do not say things like 'I will' or 'I'll'. "
-    "Always reply in the exact same natural language the user used in their "
-    "own messages (the lines marked [User]:). Never translate. Ignore the "
-    "language of assistant replies, tool calls, and tool output when choosing "
-    "your output language. "
-    "Respond with only the recap text, no quotes, no markdown, no preamble."
-)
-
 _AWAY_SUMMARY_MAX_TOKENS = 512
 
 # Recap only needs recent context — truncate to avoid "prompt too long" on
@@ -36,22 +25,7 @@ _RECENT_MESSAGE_WINDOW = 30
 
 
 def _build_away_summary_user_message(transcript: str) -> message.UserMessage:
-    body = (
-        "Language rule (highest priority): detect the natural language used "
-        "in the [User]: lines below and write your entire reply in that "
-        "language. If the user wrote Chinese, reply in Chinese; if Japanese, "
-        "reply in Japanese; and so on. Do not translate to English.\n\n"
-        "The user stepped away and is coming back. Write exactly 1-3 short "
-        "sentences. Start by stating the high-level task — what they are "
-        "building or debugging, not implementation details. Then state the "
-        "current progress or where the work stopped in one concrete phrase. "
-        "End with the concrete next step. Skip status reports and commit "
-        "recaps. Write a neutral reminder of where the work stands. Do not "
-        "evaluate the quality of ideas, do not repeat encouragement or "
-        "approval, do not present a numbered plan, and do not write from the "
-        "assistant's point of view. Never say 'I', 'I'll', or 'I will'.\n\n"
-        f"<conversation>\n{transcript}\n</conversation>"
-    )
+    body = AWAY_SUMMARY_USER_PROMPT.format(transcript=transcript)
     return message.UserMessage(parts=[message.TextPart(text=body)])
 
 
@@ -95,7 +69,7 @@ async def generate_away_summary(
 
     call_param = llm_param.LLMCallParameter(
         input=[_build_away_summary_user_message(transcript)],
-        system=_AWAY_SUMMARY_SYSTEM_PROMPT,
+        system=AWAY_SUMMARY_SYSTEM_PROMPT,
         session_id=None,
     )
     call_param.max_tokens = _AWAY_SUMMARY_MAX_TOKENS

{klaude_code-2.26.0 → klaude_code-2.28.0}/src/klaude_code/agent/cache_safe.py

@@ -107,14 +107,18 @@ def build_fork_cache_event(
             cache_hit_rate=0.0,
             fallback_used=fallback_used,
         )
-    total = usage.cached_tokens + usage.cache_write_tokens + usage.input_tokens
+    # ``Usage.input_tokens`` is provider-dependent: Anthropic/OpenAI paths store it
+    # as the full prompt total (cached + write + non-cached), while others use only
+    # the non-cached portion. ``max(input_tokens, cached + write)`` normalizes to
+    # the true total prompt size across providers (same trick as CacheTracker).
+    total = max(usage.input_tokens, usage.cached_tokens + usage.cache_write_tokens)
     hit_rate = usage.cached_tokens / total if total > 0 else 0.0
     return events.ForkCacheHitRateEvent(
         session_id=session_id,
         fork_label=fork_label,
         cache_read_tokens=usage.cached_tokens,
         cache_creation_tokens=usage.cache_write_tokens,
-        input_tokens=usage.input_tokens,
+        input_tokens=max(0, total - usage.cached_tokens - usage.cache_write_tokens),
         cache_hit_rate=hit_rate,
         fallback_used=fallback_used,
     )