refactor: move KIMI_AGENTS_MD to first message from system prompt.

AGENTS.md

@@ -173,7 +173,6 @@ Builtin variables available in system prompts:
 - `${KIMI_NOW}`: Current timestamp
 - `${KIMI_WORK_DIR}`: Working directory path
 - `${KIMI_WORK_DIR_LS}`: Directory listing output
-- `${KIMI_AGENTS_MD}`: Project AGENTS.md content
 
 ## Deployment
 

src/kimi_cli/agents/default/system.md

@@ -58,15 +58,3 @@ Use this as your basic understanding of the project structure.
 ## Date and Time
 
 The current date and time in ISO format is `${KIMI_NOW}`. This is only a reference for you when searching the web, or checking file modification time, etc. If you need the exact time, use Shell tool with proper command.
-
-# Project Information
-
-Markdown files named `AGENTS.md` usually contain the background, structure, coding styles, user preferences and other relevant information about the project. You should use this information to understand the project and the user's preferences. `AGENTS.md` files may exist at different locations in the project, but typically there is one in the project root. The following content between two `---`s is the content of the root-level `AGENTS.md` file.
-
-`${KIMI_WORK_DIR}/AGENTS.md`:
-
----
-
-${KIMI_AGENTS_MD}
-
----

src/kimi_cli/soul/agent.py

@@ -5,7 +5,7 @@
 import inspect
 import string
 from collections.abc import Mapping
-from dataclasses import asdict, dataclass
+from dataclasses import asdict, dataclass, replace
 from datetime import datetime
 from pathlib import Path
 from typing import Any
@@ -35,8 +35,6 @@ class BuiltinSystemPromptArgs:
     """The absolute path of current working directory."""
     KIMI_WORK_DIR_LS: str
     """The directory listing of current working directory."""
-    KIMI_AGENTS_MD: str  # TODO: move to first message from system prompt
-    """The content of AGENTS.md."""
 
 
 async def load_agents_md(work_dir: KaosPath) -> str | None:
@@ -63,6 +61,7 @@ class Runtime:
     denwa_renji: DenwaRenji
     approval: Approval
     labor_market: LaborMarket
+    agents_md: str
 
     @staticmethod
     async def create(
@@ -84,34 +83,26 @@ async def create(
                 KIMI_NOW=datetime.now().astimezone().isoformat(),
                 KIMI_WORK_DIR=session.work_dir,
                 KIMI_WORK_DIR_LS=ls_output,
-                KIMI_AGENTS_MD=agents_md or "",
             ),
             denwa_renji=DenwaRenji(),
             approval=Approval(yolo=yolo),
             labor_market=LaborMarket(),
+            agents_md=agents_md or "",
         )
 
     def copy_for_fixed_subagent(self) -> Runtime:
         """Clone runtime for fixed subagent."""
-        return Runtime(
-            config=self.config,
-            llm=self.llm,
-            session=self.session,
-            builtin_args=self.builtin_args,
+        return replace(
+            self,
             denwa_renji=DenwaRenji(),  # subagent must have its own DenwaRenji
-            approval=self.approval,
             labor_market=LaborMarket(),  # fixed subagent has its own LaborMarket
         )
 
     def copy_for_dynamic_subagent(self) -> Runtime:
         """Clone runtime for dynamic subagent."""
-        return Runtime(
-            config=self.config,
-            llm=self.llm,
-            session=self.session,
-            builtin_args=self.builtin_args,
+        return replace(
+            self,
             denwa_renji=DenwaRenji(),  # subagent must have its own DenwaRenji
-            approval=self.approval,
             labor_market=self.labor_market,  # dynamic subagent shares LaborMarket with main agent
         )
 
@@ -220,7 +211,8 @@ def _load_system_prompt(
         builtin_args=builtin_args,
         spec_args=args,
     )
-    return string.Template(system_prompt).substitute(asdict(builtin_args), **args)
+    template = string.Template(system_prompt)
+    return template.safe_substitute(asdict(builtin_args), **args)
 
 
 # TODO: maybe move to `KimiToolset`

src/kimi_cli/soul/context.py

@@ -1,20 +1,24 @@
 from __future__ import annotations
 
 import json
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from pathlib import Path
 
 import aiofiles
 import aiofiles.os
 from kosong.message import Message
 
+from kaos.path import KaosPath
 from kimi_cli.soul.message import system
+from kimi_cli.utils.history import filter_messages
 from kimi_cli.utils.logging import logger
 from kimi_cli.utils.path import next_available_rotation
 
 
 class Context:
-    def __init__(self, file_backend: Path):
+    def __init__(self, file_backend: Path | KaosPath):
+        if isinstance(file_backend, KaosPath):
+            file_backend = file_backend.unsafe_to_local_path()
         self._file_backend = file_backend
         self._history: list[Message] = []
         self._token_count: int = 0
@@ -154,6 +158,67 @@ async def clear(self):
         self._token_count = 0
         self._next_checkpoint_id = 0
 
+    async def reset_history(self, history: Sequence[Message]) -> None:
+        """Replace the history with the provided messages and reset counters."""
+        self._history = list(history)
+        self._token_count = 0
+        self._next_checkpoint_id = 0
+
+        async with aiofiles.open(self._file_backend, "w", encoding="utf-8") as f:
+            for message in self._history:
+                await f.write(message.model_dump_json(exclude_none=True) + "\n")
+
+    async def filter_messages(self, keep: Callable[[Message], bool]) -> bool:
+        """
+        Rewrite the history file, keeping messages that satisfy the predicate.
+        Checkpoint and usage records are preserved in place. Returns True when any message is
+        removed.
+        """
+        if not self._file_backend.exists():
+            filtered_history = [message for message in self._history if keep(message)]
+            removed = len(filtered_history) != len(self._history)
+            self._history = filtered_history
+            return removed
+
+        self._token_count = 0
+        self._next_checkpoint_id = 0
+        temp_file = self._file_backend.with_suffix(self._file_backend.suffix + ".tmp")
+        removed = False
+        new_history: list[Message] = []
+
+        async with (
+            aiofiles.open(self._file_backend, encoding="utf-8") as src,
+            aiofiles.open(temp_file, "w", encoding="utf-8") as dst,
+        ):
+            async for line in src:
+                if not line.strip():
+                    continue
+
+                line_json = json.loads(line)
+                role = line_json.get("role")
+                if role == "_usage":
+                    self._token_count = line_json["token_count"]
+                    await dst.write(line)
+                    continue
+                if role == "_checkpoint":
+                    self._next_checkpoint_id = line_json["id"] + 1
+                    await dst.write(line)
+                    continue
+
+                message = Message.model_validate(line_json)
+                if keep(message):
+                    new_history.append(message)
+                    await dst.write(message.model_dump_json(exclude_none=True) + "\n")
+                else:
+                    removed = True
+
+        self._history = new_history
+        if removed:
+            await aiofiles.os.replace(temp_file, self._file_backend)
+        else:
+            await aiofiles.os.remove(temp_file)
+        return removed
+
     async def append_message(self, message: Message | Sequence[Message]):
         logger.debug("Appending message(s) to context: {message}", message=message)
         messages = message if isinstance(message, Sequence) else [message]
@@ -163,6 +228,19 @@ async def append_message(self, message: Message | Sequence[Message]):
             for message in messages:
                 await f.write(message.model_dump_json(exclude_none=True) + "\n")
 
+    async def filter_history(self, keep: Callable[[Message], bool]) -> bool:
+        result = await filter_messages(
+            file_backend=self._file_backend,
+            history=self._history,
+            token_count=self._token_count,
+            next_checkpoint_id=self._next_checkpoint_id,
+            keep=keep,
+        )
+        self._history = result.history
+        self._token_count = result.token_count
+        self._next_checkpoint_id = result.next_checkpoint_id
+        return result.removed
+
     async def update_token_count(self, token_count: int):
         logger.debug("Updating token count in context: {token_count}", token_count=token_count)
         self._token_count = token_count