kolega-code 0.26.10__tar.gz → 0.27.0__tar.gz

{kolega_code-0.26.10 → kolega_code-0.27.0}/CHANGELOG.md

@@ -6,6 +6,168 @@ This project uses GitHub Releases for detailed generated release notes. This fil
 
 ## Unreleased
 
+## 0.27.0 - 2026-08-06
+
+### Changed
+
+- The `eval`, `exec_command`, and `lsp` tool descriptions shipped to model
+  providers are slimmer (about 450 cl100k tokens less across the three,
+  roughly 8% of the whole tool payload): prose now states decision rules and
+  contracts instead of restating parameter schema text, `eval`'s JavaScript
+  prelude folds to "same helpers as Python, camelCase" with only the
+  JS-specific pitfalls spelled out, `lsp`'s operation list groups the seven
+  operations that share the `(path, line, symbol)` arguments onto one line,
+  and `exec_command`'s `timeout`-alias note is gone (the alias layer absorbs
+  it silently). No parameter names, types, or presence change, and no
+  behavior changes ride along.
+
+- Tool definitions sent to model providers no longer duplicate parameter
+  documentation. Every tool docstring's `Args:` section is still parsed into
+  per-parameter schema descriptions, but the wire description no longer also
+  carries the whole section verbatim (and the schema descriptions no longer
+  include the raw docstring continuation-line indentation). Tools whose
+  parameters are not fully documented in their schema — freeform tools and
+  tools with enum-only schema properties such as the browser tools' `button`,
+  `action`, `level`, `part`, `image_type`, and `scale` — keep their `Args:`
+  block, since it is the only place those parameters are documented.
+
+- The per-type agent dispatch tools (`dispatch_general_agent`,
+  `dispatch_investigation_agent`, `dispatch_browser_agent`,
+  `dispatch_coding_agent`, and `dispatch_custom_agent`) are consolidated into a
+  single `dispatch_agent(agent_type, task, model_override?, browser_target?)`
+  tool. `agent_type` is an enum computed per session from the same conditions
+  that previously gated the individual tools: `general` and `investigation`
+  whenever dispatch is available, `browser` only when the browser-agent model
+  supports vision, `coding` where the coding dispatch was previously offered
+  (never for the coder itself), and custom agent names when definitions are
+  discovered. The description documents the shared dispatch mechanics once plus
+  one line per available agent type, and an unavailable `agent_type` returns an
+  error listing the valid values. Old sessions that used the removed tool names
+  still restore and display normally.
+
+- All terminal-capable agents (coder, planning, investigation, general) now
+  share a terminal-tools prompt section with codex-style guidance: prefer
+  `rg` / `rg --files` over `grep`/`find` when searching for text or files (it is
+  much faster; use alternatives if `rg` is not found), and do not use Python
+  scripts (or `eval`) to print chunks of a file — use the file-reading tools
+  instead.
+- The `resolve` tool — which applies or discards a pending `lsp_edit(apply: false)`
+  preview — is now gated like the other LSP tools. With LSP disabled (via
+  settings, `KOLEGA_CODE_LSP`, or `--lsp off`) it is removed from the model's
+  toolset entirely, since pending actions can only be created while LSP is on.
+  Applying a pending action with `resolve` now also goes through the same
+  edit-permission prompt as `edit`, `lsp_edit`, and `write`.
+- The two file-read tools are merged into one `read(file_path, offset?, limit?)`
+  tool. `offset` is the 1-indexed first line (default 1) and `limit` bounds the
+  number of lines; omitted parameters read from the top. Output is truncated to
+  2000 lines or 50KB — whichever binds first — snapped to line boundaries, with
+  actionable notices such as "[Showing lines a-b of N (50KB limit). Use
+  offset=b+1 to continue.]" instead of the old line-only warning and
+  100,000-character backstop. A single line larger than the 50KB budget gets an
+  explicit message suggesting `rg` / `exec_command` for targeted extraction.
+  `path` is accepted at the dispatch boundary as an alias for the canonical
+  `file_path`.
+
+- `write(path=…)` now also succeeds under the claude_code edit protocol, where
+  `write` binds to `claude_write(file_path, content)`: `path` is accepted at
+  the dispatch boundary as an alias for `file_path`, matching every other file
+  tool. Under the search/replace protocol `path` stays the canonical
+  parameter and passes through untouched — alias resolution is signature-aware
+  and never rewrites an argument name the bound tool itself accepts.
+
+- A successful whole-file `write` (including `hashline_write` and `apply_patch`'s
+  Add File) now records the just-written contents as read, so the read-before-edit
+  guard accepts a subsequent edit without a fresh read — exactly as it would
+  right after a read. Staleness tracking is unchanged: a file modified after the
+  write still requires a fresh read before editing.
+- The three skill host tools (`list_skills`, `activate_skill`, and
+  `read_skill_resource`) are consolidated into a single `skill` tool with the
+  same contract as the old `activate_skill`: it takes the skill name (without a
+  leading slash) and returns the activation envelope with the skill's
+  instructions, its absolute directory, and the resource file list. Activating
+  an already-active skill short-circuits as before, and an unknown name now
+  lists close matches (prefix first, then fuzzy) from the catalog so a
+  mistyped activation self-corrects in one turn. The in-prompt skill roster
+  always lists every skill by name: description text is shed first when the
+  metadata budget binds, and skills are never omitted wholesale.
+
+### Removed
+
+- The `read_entire_file` and `read_file_section` tools are gone, replaced by the
+  merged `read` tool above. Deleted: the `ReadFileTool.read_entire_file` /
+  `read_file_section` methods and their `read_only_tools` registrations, the
+  truncation notices that named `read_file_section`, and the stale
+  `dispatch_investigation_agent` docstring tool list. Existing session
+  histories keep the old tool names as recorded data and render as-is (restore
+  is name-agnostic).
+
+- The file-discovery tools are gone from the agent toolset: `glob` (which had
+  replaced `list_directory` and `find_files_by_pattern`), and `search_codebase`.
+  File and text discovery is now done through the terminal with `rg` /
+  `rg --files` (falling back to `find`/`grep`). Deleted: the `GlobTool` and
+  `SearchCodebaseTool` backends (the underlying `workspace_scan` service stays),
+  the `ToolCollection.glob` / `ToolCollection.search_codebase` methods and their
+  `read_only_tools` registrations, the stale `dispatch_investigation_agent`
+  docstring tool list (now naming the real surface, including terminal access),
+  and the `search_codebase` name from hashline history adaptation.
+  `@`-mention autocomplete (`cli/file_index.py`) keeps its exclusions by
+  inlining the constants it borrowed. Permission rules and custom-agent
+  allowlists naming the removed tools must be updated to the terminal tools
+  (`exec_command`, `write_stdin`, `kill_command`, `list_sessions`). Existing
+  session histories keep the old tool names as recorded data and render as-is.
+
+- The `sleep` tool is gone from the agent toolset: its blind wall-clock wait is
+  strictly dominated by `write_stdin`'s empty-input poll, which waits for more
+  output or process exit and returns early when the process finishes. The
+  `yield_time_ms` clamp semantics (250–30000 ms when writing, 5000–300000 ms
+  when polling) moved from the `write_stdin` docstring body into its parameter
+  description so the poll path stays discoverable. Existing session histories
+  keep the old tool name as recorded data and render as-is.
+
+- The `think_hard` tool is gone from the agent toolset, along with the thinking
+  model slot that powered it. Deleted: the `ThinkHardTool` backend and its
+  `auxiliary/tools/think_hard.system.md` prompt template, the
+  `ToolCollection.think_hard` method and its `read_only_tools` registration, the
+  `THINK_HARD_PROMPT` constant, and the `thinking_config` model slot itself.
+  `prompt` hooks now select only `"fast"` or `"long"`; the
+  `--thinking-provider`/`--thinking-model` flags, the
+  `KOLEGA_CODE_THINKING_PROVIDER`/`KOLEGA_CODE_THINKING_MODEL` env vars, and the
+  Settings Thinking slot row were removed, and a saved `thinking` slot entry in
+  `settings.json` is ignored on load. The active model's own thinking effort
+  (`--thinking-effort`, `KOLEGA_CODE_THINKING_EFFORT`) is unaffected.
+
+- The `get_host` tool is gone from the local toolset. It needs a sandbox host
+  provider, so it is now offered only when a terminal manager carrying a
+  `sandbox` attribute is injected (cloud sandbox deployments), and the
+  localhost fallback branch in the handler is deleted — a registered
+  `get_host` always has a sandbox. The gate duck-types on the attribute rather
+  than `isinstance`, so kolega-code-e2b's injected `SandboxTerminalManager`
+  (possibly subclassed from a pinned older version) keeps qualifying. Existing
+  session histories that recorded `get_host` calls keep them as data and
+  render as-is (restore is name-agnostic).
+
+- The `list_skills`, `activate_skill`, and `read_skill_resource` host tools are
+  gone, replaced by the single `skill` tool above. Deleted:
+  `SkillCatalog.read_resource` and its truncation cap and traversal guard
+  (skill resources are read with the ordinary `read` tool, whose `file_path`
+  is relative to the absolute skill directory in the activation output), the
+  model-facing list query surface (`format_model_catalog`), and the
+  omitted-skills budget pathway in the prompt roster. Existing session
+  histories keep the old tool names as recorded data and render as-is
+  (restore is name-agnostic).
+
+### Fixed
+
+- Kimi-family usage is no longer dropped when a request is served entirely from
+  the provider's prompt cache. `kimi-for-coding` / `moonshot` report
+  `input_tokens: -1` as a sentinel for "no uncached input tokens" on a full
+  cache hit; the strict usage validator previously classified that as malformed
+  and nulled the whole record, silently removing both input and output tokens
+  from session accounting for those turns. The sentinel is now interpreted as
+  zero, and the inclusive input total is reconstructed from the cache fields
+  (verified live: `-1` + 33 cached = 33 total, matching the same prompt's
+  partial-cache report of 27 uncached + 6 cached).
+
 ## 0.26.10 - 2026-08-05
 
 ### Added

{kolega_code-0.26.10 → kolega_code-0.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.26.10
+Version: 0.27.0
 Summary: Multi-agent coding in the terminal
 Project-URL: Homepage, https://kolega-ai.github.io/kolega-code/
 Project-URL: Documentation, https://kolega-ai.github.io/kolega-code/

{kolega_code-0.26.10 → kolega_code-0.27.0}/kolega_code/__init__.py

@@ -151,4 +151,4 @@ __all__ = [
     "parse_git_status_output",
 ]
 
-__version__ = "0.26.10"
+__version__ = "0.27.0"

{kolega_code-0.26.10 → kolega_code-0.27.0}/kolega_code/agent/__init__.py

@@ -51,4 +51,4 @@ __all__ = [
     "ToolExtension",
 ]
 
-__version__ = "0.26.10"
+__version__ = "0.27.0"

{kolega_code-0.26.10 → kolega_code-0.27.0}/kolega_code/agent/baseagent.py

@@ -1603,15 +1603,13 @@ class BaseAgent(LogMixin):
     async def _run_hook_prompt(self, prompt_text: str, model_hint: Optional[str]) -> str:
         """Run a `prompt` hook: a single completion on a chosen model slot.
 
-        ``model_hint`` selects a configured slot ("fast" (default), "long", or
-        "thinking"); arbitrary model ids are not used here to keep provider/API-key
+        ``model_hint`` selects a configured slot ("fast" (default) or "long");
+        arbitrary model ids are not used here to keep provider/API-key
         pairing correct across kolega's multi-provider setup.
         """
         slot = (model_hint or "fast").lower()
         if slot in ("long", "main", "long_context"):
             model_config = self.config.long_context_config
-        elif slot == "thinking":
-            model_config = self.config.thinking_config
         else:
             model_config = self.config.fast_config
 

{kolega_code-0.26.10 → kolega_code-0.27.0}/kolega_code/agent/coder.py

@@ -123,27 +123,26 @@ class CoderAgent(BaseAgent, LogMixin):
             memory_enabled=memory_enabled,
         )
 
-        # Configure tool collection with custom coder agent tools
+        # Configure tool collection with custom coder agent tools. The
+        # coder_agent_tools dispatch group already omits the "coding"
+        # agent_type, so the coder never dispatches itself.
         tool_exclusions = [
             "execute_terminal_command",
             "get_tool_list",
             "log_error",
             "log_info",
-            # Exclude task-specific dispatch tools since coder shouldn't call itself or other agents
-            "dispatch_coding_agent",
         ]
         mode_value = self.agent_mode.value if isinstance(self.agent_mode, AgentMode) else self.agent_mode
         if mode_value in (AgentMode.CLI.value, AgentMode.ASK.value):
             tool_exclusions.extend(["build_backend", "build_frontend"])
-        if sub_agent:
-            # A dispatched coder must not fan out into further sub-agents
-            tool_exclusions.append("dispatch_general_agent")
 
         tool_config = ToolCollectionConfig(
             custom_tool_groups=["coder_agent_tools"],
             tool_exclusions=tool_exclusions,
             include_memory_tools=True,
             memory_write_access=True,
+            # A dispatched coder must not fan out into further general sub-agents
+            excluded_agent_types=["general"] if sub_agent else None,
         )
 
         self.tool_collection = ToolCollection(

{kolega_code-0.26.10 → kolega_code-0.27.0}/kolega_code/agent/conversation.py

@@ -397,7 +397,7 @@ def _adapt_content_blocks_for_provider(
             call_protocol = (tool_call_protocols or {}).get(
                 block.tool_use_id, _source_edit_protocol(block, source_usage_metadata)
             )
-            is_hashline_read = block.name in {"read_entire_file", "read_file_section", "search_codebase"}
+            is_hashline_read = block.name == "read"
             if (
                 is_hashline_read
                 and call_protocol == "hashline_v2"
@@ -407,7 +407,7 @@ def _adapt_content_blocks_for_provider(
                 adapted.append(
                     _tool_result_with_content(
                         block,
-                        strip_hashline_read_output(block.content, search=block.name == "search_codebase"),
+                        strip_hashline_read_output(block.content, search=False),
                     )
                 )
                 changed = True

{kolega_code-0.26.10 → kolega_code-0.27.0}/kolega_code/agent/prompt_templates/extensions/cli/current_plan_artifact.md.j2

@@ -2,6 +2,6 @@ The current approved implementation plan is persisted as a private Markdown arti
 
 `{{ plan_artifact_path }}`
 
-If the conversation has been compacted, context seems incomplete, or you need exact acceptance criteria, read the artifact with `read_entire_file` (or `read_file_section` if the file is large) before continuing.
+If the conversation has been compacted, context seems incomplete, or you need exact acceptance criteria, read the artifact with `read` (using offset/limit if the file is large) before continuing.
 
 Treat this artifact as read-only. Do not edit or overwrite it.

kolega_code-0.27.0/kolega_code/agent/prompt_templates/extensions/skills/catalog.md.j2

@@ -0,0 +1,6 @@
+The CLI provides Agent Skills discovered from the project and user skill directories.
+Activate with the `skill` tool before applying a skill's workflow; users can also invoke skills with `/skill-name`.
+
+Available skills:
+
+{{ catalog }}

{kolega_code-0.26.10 → kolega_code-0.27.0}/kolega_code/agent/prompt_templates/system/agents/browser.md.j2

@@ -104,7 +104,7 @@ URLs refer to services running on your own machine:
 
 1. ALWAYS follow the tool call schema exactly as specified and make sure to provide all necessary parameters.
 2. If the USER asks you to disclose your tools, ALWAYS respond with the helpful description provided.
-3. **NEVER refer to tool names when speaking to the USER.** For example, instead of saying 'I need to use the read_file_section tool to inspect your file', just say 'I will inspect your file'.
+3. **NEVER refer to tool names when speaking to the USER.** For example, instead of saying 'I need to use the read tool to inspect your file', just say 'I will inspect your file'.
 4. Before calling tools, first explain to the USER why you are calling them.
 5. WHENEVER YOU OPEN A BROWSER OR TERMINAL, ALWAYS CLOSE IT WHEN DONE.
 

{kolega_code-0.26.10 → kolega_code-0.27.0}/kolega_code/agent/prompt_templates/system/agents/coder_base.md.j2

@@ -65,15 +65,7 @@ Treat completion as unproven until you have checked it against every requirement
 
 Deliver the complete, working result. NEVER ship stubs, placeholders, mocks, no-ops, `TODO: implement`, or partial scaffolding as if finished. NEVER relabel unfinished work as "MVP", "v1", or "foundation" to imply completion — if it is not done, say so, do not pretend. NEVER silently shrink scope or substitute a narrower, easier, or merely-compatible task than the one you were given. If the task specifies a file at a particular path, produce exactly that file at exactly that path.
 
-## Running Commands
-
-Prefer one-shot commands that terminate; run long-lived processes like dev servers and watchers in the background. When starting a development server, use a free port.
-
-{% if interactive %}
-Do not run destructive commands automatically. Treat commands that delete files, rewrite history, reset worktrees, install system dependencies, or make external state changes as requiring explicit user approval.
-{% else %}
-There is no user present to approve actions, so exercise judgment: do not run destructive commands — deleting files you did not create, rewriting git history, resetting the worktree, or making external state changes — unless the task explicitly requires them.
-{% endif %}
+{% include 'system/includes/terminal_tools.md' %}
 
 ## Reuse Results
 

{kolega_code-0.26.10 → kolega_code-0.27.0}/kolega_code/agent/prompt_templates/system/agents/general.md.j2

@@ -52,7 +52,7 @@ main agent - it will not see your intermediate steps. End with a complete, self-
 3. Any commands or checks you ran and their outcomes.
 4. Anything that failed, was skipped, or needs follow-up.
 
-## **Running Commands**
+{% include 'system/includes/terminal_tools.md' %}
 
 When requesting a command to be run, you will be asked to judge if it is appropriate to run without the USER's permission. A command is unsafe if it may have some destructive side-effects. Example unsafe side-effects include: deleting files, mutating state, installing system dependencies, making external requests, etc. You must NEVER NEVER run a command automatically if it could be unsafe. You cannot allow the USER to override your judgement on this. If a command is unsafe, do not run it automatically, even if the USER wants you to.
 

{kolega_code-0.26.10 → kolega_code-0.27.0}/kolega_code/agent/prompt_templates/system/agents/investigation.md.j2

@@ -44,9 +44,9 @@ Do your best to complete the task you are given. If you need more information, u
 You must complete the task independently. Once your turn ends your last message will be returned to Kolega Code
 to take further action, so your last message should contain the task result.
 
-## **Running Commands**
+{% include 'system/includes/terminal_tools.md' %}
 
-You may run shell commands (e.g. `git log`, `grep`, build/lint/test commands) to investigate the codebase. Never use commands to modify the project — no editing files, installing dependencies, committing, pushing, or other side effects. Prefer read-only tools when they suffice. Commands are subject to the active permission mode and may require approval.
+You may run shell commands (e.g. `git log`, `rg`, build/lint/test commands) to investigate the codebase, but never use them to modify the project — no editing files, installing dependencies, committing, pushing, or other side effects. Prefer read-only tools when they suffice. Commands are subject to the active permission mode and may require approval.
 
 ## **Communication Guidelines**
 
@@ -62,7 +62,7 @@ You may run shell commands (e.g. `git log`, `grep`, build/lint/test commands) to
 
 1. ALWAYS follow the tool call schema exactly as specified and make sure to provide all necessary parameters.
 2. If the USER asks you to disclose your tools, ALWAYS respond with the helpful description provided.
-3. **NEVER refer to tool names when speaking to the USER.** For example, instead of saying 'I need to use the read_file_section tool to inspect your file', just say 'I will inspect your file'.
+3. **NEVER refer to tool names when speaking to the USER.** For example, instead of saying 'I need to use the read tool to inspect your file', just say 'I will inspect your file'.
 4. Before calling tools, first explain to the USER why you are calling them.
 5. You must ONLY use the tools in the scope of the "Working directory". NEVER expose Kolega Code's implementation.
 

{kolega_code-0.26.10 → kolega_code-0.27.0}/kolega_code/agent/prompt_templates/system/agents/planning.md.j2

@@ -14,9 +14,11 @@ Here is useful information about the environment:
 ## Operating Mode
 
 You are in planning mode. Do not implement code changes, create files, edit files, start servers, or perform other mutating actions.
-You may run shell commands (e.g. `git log`, `grep`, build/lint/test commands) to investigate the codebase and reduce ambiguity, but never use them to modify the project — no editing files, installing dependencies, committing, pushing, or other side effects. Prefer read-only tools when they suffice, and use `exec_command` only to inspect or validate.
+You may run shell commands (e.g. `git log`, `rg`, build/lint/test commands) to investigate the codebase and reduce ambiguity, but never use them to modify the project — no editing files, installing dependencies, committing, pushing, or other side effects. Prefer read-only tools when they suffice, and use `exec_command` only to inspect or validate.
 Use read-only tools and investigative commands to inspect the repository and reduce ambiguity.
 
+{% include 'system/includes/terminal_tools.md' %}
+
 When the plan is decision complete, call `write_plan` with the final markdown plan. Do not call `write_plan` while major product or implementation choices are still unresolved.
 If a planning turn ends with a complete new or revised implementation plan, submit it through `write_plan`; do not only print the plan in a normal assistant response.
 When user answers, constraints, or follow-up discussion change the plan, the next `write_plan` payload must be a complete replacement plan that incorporates those decisions and can be implemented without reading earlier discussion.

kolega_code-0.27.0/kolega_code/agent/prompt_templates/system/includes/terminal_tools.md

@@ -0,0 +1,11 @@
+## Running Commands
+
+Prefer one-shot commands that terminate; run long-lived processes like dev servers and watchers in the background. When starting a development server, use a free port.
+
+Do not run destructive commands automatically — deleting files, rewriting history, resetting worktrees, installing system dependencies, or making external state changes — unless a user has explicitly approved them or the task explicitly requires them.
+
+## Searching and Reading Files
+
+When searching for text or files, prefer `rg` / `rg --files` over grep/find — it is much faster. If `rg` is not found, use alternatives.
+
+Do not use python scripts (or `eval`) to print chunks of a file — use the file-reading tools instead.

{kolega_code-0.26.10 → kolega_code-0.27.0}/kolega_code/agent/prompt_templates/user_tasks/cli/implement_plan.md.j2

@@ -1,7 +1,7 @@
 Implement the approved plan below. Follow it as the source of truth, but still inspect the code before editing and run appropriate checks.
 {% if plan_artifact_path %}
 
-The approved plan is also persisted at `{{ plan_artifact_path }}`. If the conversation is compacted or you need the exact plan again later, read that file with `read_entire_file` (or `read_file_section` if needed). Treat it as read-only.
+The approved plan is also persisted at `{{ plan_artifact_path }}`. If the conversation is compacted or you need the exact plan again later, read that file with `read` (using offset/limit if needed). Treat it as read-only.
 {% endif %}
 {% if gigacode_enabled %}
 

{kolega_code-0.26.10 → kolega_code-0.27.0}/kolega_code/agent/prompts.py

@@ -37,7 +37,6 @@ def render_prompt_template(template_name: str, **variables: Any) -> str:
     return _prompt_template(template_name).render(**variables).strip()
 
 
-THINK_HARD_PROMPT = render_prompt_template("auxiliary/tools/think_hard.system.md")
 COMPRESSION_SUMMARY_SYSTEM_PROMPT = render_prompt_template("auxiliary/compression/summary.system.md")
 SHELL_SAFETY_SYSTEM_PROMPT = render_prompt_template("auxiliary/terminal/safety.system.md")
 SHELL_COMPRESSION_SYSTEM_PROMPT = render_prompt_template("auxiliary/terminal/output_summary.system.md")

{kolega_code-0.26.10 → kolega_code-0.27.0}/kolega_code/agent/tool_backend/edit_tool.py

@@ -67,6 +67,22 @@ class EditTool(BaseTool):
         if self.filesystem.exists(normalized) and self.filesystem.is_file(normalized):
             self._read_versions[normalized] = self._content_digest(self.filesystem.read_text(normalized))
 
+    def _write_file(self, path: str, content: str) -> None:
+        """Write ``content`` to ``path`` (creating parents) and record it as read-equivalent.
+
+        A successful whole-file write leaves the file's current contents known,
+        so the result is recorded through the same mechanism a model-facing
+        read uses (``observe_read``): the edit guard then accepts the file
+        exactly as it would accept a freshly read one, and still rejects it
+        once the file changes on disk. This is the single write path for every
+        edit protocol's write handler.
+        """
+        parent = self.filesystem.get_parent(path)
+        if parent and parent != "." and not self.filesystem.exists(parent):
+            self.filesystem.create_directory(parent)
+        self.filesystem.write_text(path, content)
+        self.observe_read(path)
+
     async def claude_edit(
         self,
         file_path: str,
@@ -119,10 +135,7 @@ class EditTool(BaseTool):
             return blocked_msg
 
         def _write() -> None:
-            parent = self.filesystem.get_parent(path)
-            if parent and parent != "." and not self.filesystem.exists(parent):
-                self.filesystem.create_directory(parent)
-            self.filesystem.write_text(path, updated_content)
+            self._write_file(path, updated_content)
 
         self._mutate_with_optional_snapshot(
             tool_name="edit",
@@ -140,7 +153,6 @@ class EditTool(BaseTool):
             tool_call_id=getattr(self.caller, "current_tool_execution_id", None),
             tool_name="edit",
         )
-        self._read_versions[path] = self._content_digest(self.filesystem.read_text(path))
         result = f"Edited {path}" if exists else f"Created {path}"
         diagnostics = await self._maybe_append_lsp_diagnostics(path)
         return result + diagnostics
@@ -169,10 +181,7 @@ class EditTool(BaseTool):
             return blocked_msg
 
         def _write() -> None:
-            parent = self.filesystem.get_parent(path)
-            if parent and parent != "." and not self.filesystem.exists(parent):
-                self.filesystem.create_directory(parent)
-            self.filesystem.write_text(path, content)
+            self._write_file(path, content)
 
         self._mutate_with_optional_snapshot(
             tool_name="write",
@@ -190,7 +199,6 @@ class EditTool(BaseTool):
             tool_call_id=getattr(self.caller, "current_tool_execution_id", None),
             tool_name="write",
         )
-        self._read_versions[path] = self._content_digest(self.filesystem.read_text(path))
         result = f"Wrote {path}"
         diagnostics = await self._maybe_append_lsp_diagnostics(path)
         return result + diagnostics
@@ -262,8 +270,6 @@ class EditTool(BaseTool):
                 except Exception:
                     old_content = None
 
-            parent_dir = self.filesystem.get_parent(path)
-
             # Preserve the file's dominant line ending on overwrite; new files
             # keep the line endings the caller provided (typically LF).
             if exists and old_content is not None:
@@ -271,9 +277,7 @@ class EditTool(BaseTool):
                 content = self._normalize_line_endings(content, line_ending)
 
             def _write() -> None:
-                if parent_dir and parent_dir != "." and not self.filesystem.exists(parent_dir):
-                    self.filesystem.create_directory(parent_dir)
-                self.filesystem.write_text(path, content)
+                self._write_file(path, content)
 
             self._mutate_with_optional_snapshot(
                 tool_name="write",
@@ -404,10 +408,7 @@ class EditTool(BaseTool):
         snapshot_paths = list(dict.fromkeys(snapshot_paths))
 
         def _write() -> None:
-            parent = self.filesystem.get_parent(target)
-            if parent and parent != "." and not self.filesystem.exists(parent):
-                self.filesystem.create_directory(parent)
-            self.filesystem.write_text(target, updated)
+            self._write_file(target, updated)
             if destination is not None and self.filesystem.exists(source):
                 self.filesystem.remove(source, missing_ok=True)
 
@@ -540,10 +541,7 @@ class EditTool(BaseTool):
             for path in sorted(
                 (item for item in changed if working[item] is not None), key=lambda item: len(Path(item).parts)
             ):
-                parent = self.filesystem.get_parent(path)
-                if parent and parent != "." and not self.filesystem.exists(parent):
-                    self.filesystem.create_directory(parent)
-                self.filesystem.write_text(path, working[path] or "")
+                self._write_file(path, working[path] or "")
 
         self._mutate_with_optional_snapshot(
             tool_name="apply_patch",
@@ -661,7 +659,7 @@ class EditTool(BaseTool):
                 tool_name=tool_name,
                 reason=f"{tool_name} {path}",
                 paths=[path],
-                mutate=lambda: self.filesystem.write_text(path, normalized_updated),
+                mutate=lambda: self._write_file(path, normalized_updated),
             )
 
             await self.send_edit_preview(