drydock-cli 2.7.16__tar.gz → 2.7.18__tar.gz

drydock_cli-2.7.18/.auto_release.lock

@@ -0,0 +1 @@
+341821

{drydock_cli-2.7.16 → drydock_cli-2.7.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.7.16
+Version: 2.7.18
 Summary: Local-first CLI coding agent — tested with Gemma 4 26B via vLLM
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock

{drydock_cli-2.7.16 → drydock_cli-2.7.18}/drydock/admiral/detectors.py

@@ -80,18 +80,28 @@ def detect_struggle(messages: Sequence[LLMMessage], threshold: int = 20) -> Find
                 calls_since_write += 1
     if calls_since_write < threshold:
         return None
-    hint = (
-        "Either (a) you already have enough context — commit to a plan and "
-        "start writing code now, or (b) you're genuinely stuck — stop and "
-        "report what's blocking you to the user."
-    )
-    return Finding(
-        code=f"struggle:{calls_since_write}:{last_write_tool or 'none'}",
-        directive=(
+    # Stable code (no count) so DEDUP_WINDOW_SEC suppresses repeated firings.
+    # Previously included the count, which caused 33 identical interventions
+    # in a single session (each with a unique key that bypassed dedup).
+    code = f"struggle:{last_write_tool or 'none'}"
+    if calls_since_write >= 30:
+        directive = (
+            f"Admiral: you have made {calls_since_write} tool calls without "
+            f"writing any file — search_replace is clearly not finding the text. "
+            f"STOP retrying. Call `write_file` with `overwrite=True` to rewrite "
+            f"the target file from scratch right now."
+        )
+    else:
+        hint = (
+            "Either (a) you already have enough context — commit to a plan and "
+            "start writing code now, or (b) you're genuinely stuck — stop and "
+            "report what's blocking you to the user."
+        )
+        directive = (
             f"Admiral: you have made {calls_since_write} tool calls without "
             f"writing or editing any file. {hint}"
-        ),
-    )
+        )
+    return Finding(code=code, directive=directive)
 
 
 def run_all(messages: Sequence[LLMMessage]) -> list[Finding]:

{drydock_cli-2.7.16 → drydock_cli-2.7.18}/drydock/core/agent_loop.py

@@ -1131,10 +1131,12 @@ class AgentLoop:
         token-level sampling bumps don't help when the model picks
         the SAME serialized args every time.
 
-        Conservative thresholds — only fires on truly pathological
-        repeat counts that would never be a "valid retry":
+        Thresholds tuned for 45-prompt session windows (stress sessions
+        reset every 45 prompts — a threshold of 12 never fires in practice
+        because the model loops 4-8 times then moves on; admiral advisories
+        fire at 3 but the model ignores them):
           search_replace, write_file, bash: after 8 identical calls
-          read_file, grep, glob, ls: after 12 identical calls
+          read_file, grep, glob, ls: after 5 identical calls
         """
         args_str = json.dumps(tool_call.args_dict, sort_keys=True, default=str)
         sig = hashlib.sha256(
@@ -1143,7 +1145,7 @@ class AgentLoop:
         count, last_result = self._tool_call_history.get(sig, (0, ""))
         tool_name = tool_call.tool_name
         is_readonly = tool_name in ("grep", "read_file", "glob", "ls")
-        threshold = 12 if is_readonly else 8
+        threshold = 5 if is_readonly else 8
         if count < threshold:
             return None
         return (
@@ -2379,6 +2381,30 @@ class AgentLoop:
         if len(recent_sr) >= 2 and recent_sr[0] == recent_sr[1]:
             return "WARNING|search_replace"
 
+        # Early check: write_file with _truncated args twice in a row for the
+        # same path.  format.py already embeds the file content in the error,
+        # but Gemma 4 ignores the advisory and retries identically.  Mute
+        # write_file for 1 turn so the model must use read_file or
+        # search_replace instead — same pattern as the search_replace check.
+        recent_wf_truncated: list[str] = []
+        for msg in reversed(self.messages[-20:]):
+            if msg.role == Role.assistant and msg.tool_calls:
+                for tc in msg.tool_calls:
+                    if tc.function and tc.function.name == "write_file":
+                        try:
+                            args = json.loads(tc.function.arguments or "{}")
+                            if args.get("_truncated"):
+                                p = (args.get("file_path") or args.get("path") or "")
+                                recent_wf_truncated.append(p)
+                        except (json.JSONDecodeError, AttributeError):
+                            pass
+                if len(recent_wf_truncated) >= 2:
+                    break
+        if (len(recent_wf_truncated) >= 2
+                and recent_wf_truncated[0] == recent_wf_truncated[1]):
+            self._hot_tool_path = ("write_file", recent_wf_truncated[0])
+            return "FORCE_STOP"
+
         sigs: list[str] = []
         tool_names: list[str] = []
         lookback = 0

{drydock_cli-2.7.16 → drydock_cli-2.7.18}/drydock/core/llm/format.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import json
 import logging
 import re as _re
+from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from pydantic import BaseModel, ConfigDict, Field, ValidationError
@@ -378,16 +379,43 @@ class APIToolFormatHandler:
                 path_hint = (parsed_call.raw_args.get("path")
                              or parsed_call.raw_args.get("file_path")
                              or "")
-                hint = f" Re-read `{path_hint}` with read_file first." if path_hint else ""
+                # Auto-embed the current file content so the model can
+                # rewrite immediately without an extra read_file round-trip.
+                file_embed = ""
+                if path_hint:
+                    try:
+                        p = Path(path_hint)
+                        if p.exists() and p.is_file():
+                            raw = p.read_text(errors="replace")
+                            lines = raw.splitlines()
+                            max_lines = 120
+                            if len(lines) <= max_lines:
+                                file_embed = (
+                                    f"\n\nCurrent file content of `{path_hint}`:\n"
+                                    f"```\n{raw}\n```\n"
+                                    f"Rewrite it now using write_file with the correct content."
+                                )
+                            else:
+                                snippet = "\n".join(lines[:max_lines])
+                                file_embed = (
+                                    f"\n\nCurrent file content of `{path_hint}` "
+                                    f"(first {max_lines} of {len(lines)} lines):\n"
+                                    f"```\n{snippet}\n```\n"
+                                    f"Use read_file to see the rest, then rewrite with write_file."
+                                )
+                    except Exception:
+                        pass
+                if not file_embed and path_hint:
+                    file_embed = f" Re-read `{path_hint}` with read_file first."
                 failed_calls.append(
                     FailedToolCall(
                         tool_name=parsed_call.tool_name,
                         call_id=parsed_call.call_id,
                         error=(
-                            f"{parsed_call.tool_name}: your call used a "
+                            f"your call used a "
                             f"truncated history entry as a template (it contained "
                             f"'_truncated'/'_original_bytes' instead of real "
-                            f"arguments).{hint} Provide the full required arguments."
+                            f"arguments).{file_embed} Provide the full required arguments."
                         ),
                     )
                 )
@@ -410,11 +438,56 @@ class APIToolFormatHandler:
                     and "path" in error_str
                     and "Field required" in error_str
                 ):
+                    # Try to infer path from the first comment line of content.
+                    # Gemma 4 frequently calls write_file(content="...") without path.
+                    content_val = parsed_call.raw_args.get("content", "")
+                    inferred_path: str | None = None
+                    if content_val:
+                        for _line in content_val.splitlines()[:5]:
+                            _line = _line.strip()
+                            _m = _re.match(
+                                r'^#\s+([\w./+-]+\.(?:py|js|ts|json|yaml|yml|toml|md|txt|sh|cfg|ini))\s*$',
+                                _line,
+                            )
+                            if _m:
+                                inferred_path = _m.group(1)
+                                break
+                    if inferred_path:
+                        try:
+                            _new_args = dict(parsed_call.raw_args)
+                            _new_args["path"] = inferred_path
+                            validated_args = args_model.model_validate(_new_args)
+                            resolved_calls.append(
+                                ResolvedToolCall(
+                                    tool_name=parsed_call.tool_name,
+                                    tool_class=tool_class,
+                                    validated_args=validated_args,
+                                    call_id=parsed_call.call_id,
+                                )
+                            )
+                            continue
+                        except ValidationError:
+                            pass
+                    # List project .py files as hints so the model can pick the right one
+                    _candidates: list[str] = []
+                    try:
+                        _candidates = [
+                            str(p.relative_to(Path.cwd()))
+                            for p in sorted(Path.cwd().rglob("*.py"))
+                            if "__pycache__" not in str(p) and ".git" not in str(p)
+                        ][:12]
+                    except Exception:
+                        pass
+                    _hint = (
+                        f"Project .py files: {', '.join(_candidates)}"
+                        if _candidates
+                        else "Use read_file or glob to list available files."
+                    )
                     error_msg = (
-                        "write_file: missing required `path` parameter. "
-                        "You must pass BOTH `path` AND `content` as separate arguments. "
-                        'Fix: write_file(path="your/file.py", content="..."). '
-                        "Do NOT omit `path`."
+                        "missing required `path` parameter. "
+                        "You must pass BOTH `path` AND `content` as separate arguments: "
+                        'write_file(path="pkg/file.py", content="..."). '
+                        f"Do NOT omit `path`. {_hint}"
                     )
                 else:
                     error_msg = f"Invalid arguments: {e}"

{drydock_cli-2.7.16 → drydock_cli-2.7.18}/drydock/core/tools/builtins/read_file.py

@@ -45,7 +45,7 @@ class ReadFileResult(BaseModel):
     content: str
     lines_read: int
     was_truncated: bool = Field(
-        description="True if the reading was stopped due to the max_read_bytes limit."
+        description="True if the reading was stopped due to the line limit or max_read_bytes limit."
     )
 
 
@@ -130,6 +130,19 @@ class ReadFile(
         read_result = await self._read_file(args, file_path)
         content = "".join(read_result.lines)
 
+        # When stopped by the line limit (not byte limit), append a hint so
+        # the model knows to paginate with offset= instead of re-reading.
+        if (
+            read_result.was_truncated
+            and args.limit is not None
+            and len(read_result.lines) == args.limit
+        ):
+            next_offset = args.offset + args.limit
+            content += (
+                f"\n[lines {args.offset + 1}–{next_offset} shown; "
+                f"use offset={next_offset} to read more]"
+            )
+
         # Record read state so Write/Edit can enforce Read-before-Write
         # and so future re-reads can dedup against this one.
         if read_state is not None:
@@ -195,6 +208,7 @@ class ReadFile(
                         continue
 
                     if args.limit is not None and len(lines_to_return) >= args.limit:
+                        was_truncated = True
                         break
 
                     line_bytes = len(line.encode("utf-8"))

{drydock_cli-2.7.16 → drydock_cli-2.7.18}/drydock/core/tools/builtins/search_replace.py

@@ -131,6 +131,74 @@ class SearchReplace(
             file_path, search_replace_blocks = self._prepare_and_validate_args(args)
         except ToolError as e:
             err_msg = str(e)
+            if err_msg.startswith("Empty content provided.") or err_msg.startswith("File path is required."):
+                # Model sent search_replace with missing content or file_path.
+                # Convert to a soft result so the model corrects — a ToolError
+                # causes panic-retry loops (feedback: never raise ToolError for
+                # loop detection). Track count to escalate on repeat offenses.
+                empty_state = self.state.__dict__.setdefault("_sr_empty_history", {})
+                key = args.file_path.strip() or "<no-path>"
+                entry = empty_state.get(key, {"count": 0})
+                entry["count"] += 1
+                empty_state[key] = entry
+                count = entry["count"]
+                escalate = count >= 2
+                extra = ""
+                if escalate:
+                    # Show project files so model can recover context
+                    try:
+                        py_files = sorted(
+                            str(p.relative_to(Path.cwd()))
+                            for p in Path.cwd().rglob("*.py")
+                            if "__pycache__" not in str(p) and ".git" not in str(p)
+                        )[:20]
+                        extra = (
+                            f"\n[This is the #{count} empty search_replace on '{key}'. "
+                            f"Stop retrying. Current .py files in project:\n"
+                            + "\n".join(f"  {f}" for f in py_files)
+                            + "\nUse write_file to create a file, or read_file to "
+                            f"see file contents before editing.]"
+                        )
+                    except Exception:
+                        extra = (
+                            f"\n[This is the #{count} empty search_replace on '{key}'. "
+                            "Stop retrying. Use write_file or read the file first.]"
+                        )
+                yield SearchReplaceResult(
+                    file=key,
+                    blocks_applied=0,
+                    lines_changed=0,
+                    content=err_msg + extra,
+                )
+                return
+            if err_msg.startswith("Path is not a file:"):
+                # Model passed a directory instead of a file path.
+                # Return a result (not raise) so the model corrects the call
+                # rather than retrying the same directory path in a loop.
+                dir_path_str = args.file_path.strip()
+                dir_path = Path(dir_path_str).expanduser()
+                if not dir_path.is_absolute():
+                    dir_path = Path.cwd() / dir_path
+                dir_path = dir_path.resolve()
+                if dir_path.is_dir():
+                    try:
+                        files = sorted(p.name for p in dir_path.iterdir() if p.is_file())
+                    except OSError:
+                        files = []
+                    files_list = "\n".join(f"  {f}" for f in files[:20]) or "  (empty directory)"
+                    yield SearchReplaceResult(
+                        file=str(dir_path),
+                        blocks_applied=0,
+                        lines_changed=0,
+                        content=(
+                            f"PATH ERROR: '{dir_path}' is a directory, not a file. "
+                            f"search_replace requires a path to a specific file.\n"
+                            f"Files in that directory:\n{files_list}\n"
+                            f"Specify the full path including the filename, e.g. "
+                            f"'{dir_path}/<filename.py>'"
+                        ),
+                    )
+                    return
             if err_msg.startswith("NO_BLOCKS:"):
                 # Gemma 4 sent raw code without SEARCH/REPLACE markers.
                 # CAREFULLY fall back to full file overwrite — but refuse if
@@ -383,18 +451,38 @@ class SearchReplace(
             state[fail_key] = entry
             if entry["count"] >= 2:
                 try:
-                    head = original_content[:2000]
                     line_count = original_content.count("\n")
-                    error_message += (
-                        f"\n\n[LOOP-BREAKER: this is the #{entry['count']} "
-                        f"consecutive search_replace failure on "
-                        f"{file_path.name}. Stop retrying the same search. "
-                        f"Actual file content (first 2000 chars of "
-                        f"{line_count} lines):\n"
-                        f"-----FILE START-----\n{head}\n-----FILE END-----\n"
-                        f"Use THIS exact text as your search target, OR "
-                        f"abandon this edit and try write_file.]"
-                    )
+                    count = entry["count"]
+                    if count >= 3:
+                        # Show full file (up to 4000 chars) and prohibit retry.
+                        body = original_content[:4000]
+                        tail = (
+                            f"\n...[truncated, {line_count} lines total]"
+                            if len(original_content) > 4000 else ""
+                        )
+                        error_message += (
+                            f"\n\n[HARD-STOP: this is the #{count} consecutive "
+                            f"search_replace failure on {file_path.name}. "
+                            f"Your search text was NOT found in the file. "
+                            f"DO NOT retry search_replace with the same or similar text. "
+                            f"REQUIRED action: call write_file with overwrite=True "
+                            f"and provide the complete new file content. "
+                            f"Full file content below — use this as the basis "
+                            f"for your write_file call:\n"
+                            f"-----FILE START-----\n{body}{tail}\n-----FILE END-----]"
+                        )
+                    else:
+                        head = original_content[:2000]
+                        error_message += (
+                            f"\n\n[LOOP-BREAKER: this is the #{count} "
+                            f"consecutive search_replace failure on "
+                            f"{file_path.name}. Stop retrying the same search. "
+                            f"Actual file content (first 2000 chars of "
+                            f"{line_count} lines):\n"
+                            f"-----FILE START-----\n{head}\n-----FILE END-----\n"
+                            f"Use THIS exact text as your search target, OR "
+                            f"abandon this edit and try write_file.]"
+                        )
                 except Exception:
                     pass
 

{drydock_cli-2.7.16 → drydock_cli-2.7.18}/drydock/core/tools/builtins/write_file.py

@@ -735,6 +735,19 @@ class WriteFile(
             file_path = Path.cwd() / file_path
         file_path = file_path.resolve()
 
+        if file_path.is_dir():
+            try:
+                children = sorted(p.name for p in file_path.iterdir())[:20]
+                listing = ", ".join(children) if children else "(empty)"
+            except OSError:
+                listing = "(unreadable)"
+            raise ToolError(
+                f"'{file_path}' is a directory, not a file. "
+                f"Specify the exact file path inside it.\n"
+                f"Files in that directory: {listing}\n"
+                f"Example: {file_path}/{children[0] if children else 'yourfile.py'}"
+            )
+
         file_existed = file_path.exists()
 
         if file_existed and not args.overwrite:

{drydock_cli-2.7.16 → drydock_cli-2.7.18}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "2.7.16"
+version = "2.7.18"
 description = "Local-first CLI coding agent — tested with Gemma 4 26B via vLLM"
 readme = "README.md"
 requires-python = ">=3.12"

drydock_cli-2.7.18/tests/core/test_circuit_breaker_readonly_threshold.py

@@ -0,0 +1,93 @@
+"""Regression test: read_file circuit breaker fires at threshold 5, not 12.
+
+Stress sessions reset every 45 prompts. With threshold=12, the model could
+loop 11× on the same read_file call before being blocked — admiral advisories
+fire at 3× but are ignored. Threshold=5 actually engages the block before
+the session's budget is exhausted.
+"""
+import hashlib
+import json
+import unittest
+from unittest.mock import MagicMock
+
+
+def _make_circuit_breaker_check():
+    """Import and bind just the circuit breaker logic for unit testing."""
+    from drydock.core.agent_loop import AgentLoop
+
+    loop = AgentLoop.__new__(AgentLoop)
+    loop._tool_call_history = {}
+    loop._get_attempted_summary = lambda: ""
+    return loop
+
+
+class TestCircuitBreakerReadonlyThreshold(unittest.TestCase):
+    def _make_tool_call(self, name, args):
+        tc = MagicMock()
+        tc.tool_name = name
+        tc.args_dict = args
+        tc.call_id = "test-id"
+        return tc
+
+    def _record(self, loop, tool_call, result="some content"):
+        from drydock.core.agent_loop import AgentLoop
+        AgentLoop._circuit_breaker_record(loop, tool_call, result)
+
+    def test_read_file_blocks_at_5(self):
+        """Circuit breaker fires on the 6th identical call (threshold=5 means count>=5 blocks)."""
+        loop = _make_circuit_breaker_check()
+        tc = self._make_tool_call("read_file", {"path": "foo.py", "offset": 150, "limit": 100})
+
+        # First 5 calls: should not block
+        for i in range(5):
+            result = loop._circuit_breaker_check(tc)
+            self.assertIsNone(result, f"Expected no block on call {i+1}, got: {result}")
+            self._record(loop, tc)
+
+        # 6th call: should block (count=5 >= threshold=5)
+        result = loop._circuit_breaker_check(tc)
+        self.assertIsNotNone(result, "Expected circuit breaker to fire on 6th identical read_file")
+        self.assertIn("read_file", result)
+
+    def test_bash_still_blocks_at_8(self):
+        """bash threshold=8, so blocks on 9th call (count=8 >= threshold=8)."""
+        loop = _make_circuit_breaker_check()
+        tc = self._make_tool_call("bash", {"command": "ls -la"})
+
+        for i in range(8):
+            result = loop._circuit_breaker_check(tc)
+            self.assertIsNone(result, f"Expected no block on bash call {i+1}")
+            self._record(loop, tc)
+
+        result = loop._circuit_breaker_check(tc)
+        self.assertIsNotNone(result, "Expected circuit breaker to fire on 9th identical bash")
+
+    def test_grep_blocks_at_5(self):
+        loop = _make_circuit_breaker_check()
+        tc = self._make_tool_call("grep", {"pattern": "def foo", "path": "bar.py"})
+
+        for i in range(5):
+            result = loop._circuit_breaker_check(tc)
+            self.assertIsNone(result)
+            self._record(loop, tc)
+
+        # 6th call blocks (count=5 >= threshold=5)
+        result = loop._circuit_breaker_check(tc)
+        self.assertIsNotNone(result, "Expected circuit breaker to fire on 6th identical grep")
+
+    def test_different_args_not_blocked(self):
+        loop = _make_circuit_breaker_check()
+
+        # 5 reads of foo.py at offset 150
+        tc1 = self._make_tool_call("read_file", {"path": "foo.py", "offset": 150})
+        for _ in range(5):
+            self._record(loop, tc1)
+
+        # Different offset should not be blocked
+        tc2 = self._make_tool_call("read_file", {"path": "foo.py", "offset": 200})
+        result = loop._circuit_breaker_check(tc2)
+        self.assertIsNone(result, "Different args should not be blocked")
+
+
+if __name__ == "__main__":
+    unittest.main()

drydock_cli-2.7.18/tests/test_admiral_struggle_dedup.py

@@ -0,0 +1,68 @@
+"""Regression tests for struggle detector dedup fix.
+
+Before the fix, the finding code was f"struggle:{count}:{tool}" — each count
+was a unique key, bypassing DEDUP_WINDOW_SEC and producing 33 identical
+interventions in one session that the model ignored.
+
+After the fix, the code is stable (f"struggle:{tool}") so a single entry
+in recent_findings suppresses repeat firings within the 60-second window.
+"""
+from __future__ import annotations
+
+from drydock.admiral.detectors import detect_struggle
+from drydock.core.types import FunctionCall, LLMMessage, Role, ToolCall
+
+
+def _assistant(tool: str, args: str = "{}") -> LLMMessage:
+    return LLMMessage(
+        role=Role.assistant,
+        content="",
+        tool_calls=[ToolCall(function=FunctionCall(name=tool, arguments=args))],
+    )
+
+
+def _make_msgs(write_tool: str, non_write_count: int) -> list[LLMMessage]:
+    msgs: list[LLMMessage] = [LLMMessage(role=Role.user, content="build it")]
+    msgs.append(_assistant(write_tool, '{"path":"x.py","content":"x"}'))
+    msgs.append(LLMMessage(role=Role.tool, content="ok"))
+    for i in range(non_write_count):
+        msgs.append(_assistant("read_file", f'{{"path":"f{i}.py"}}'))
+        msgs.append(LLMMessage(role=Role.tool, content="content"))
+    return msgs
+
+
+def test_struggle_code_is_stable_no_count() -> None:
+    """Finding code must NOT include the count so dedup works across counts."""
+    msgs20 = _make_msgs("search_replace", 20)
+    msgs33 = _make_msgs("search_replace", 33)
+    f20 = detect_struggle(msgs20)
+    f33 = detect_struggle(msgs33)
+    assert f20 is not None
+    assert f33 is not None
+    # Same stable code regardless of count
+    assert f20.code == f33.code
+    assert "20" not in f20.code
+    assert "33" not in f33.code
+
+
+def test_struggle_escalated_directive_at_30() -> None:
+    """At 30+ non-write calls, directive must mention write_file overwrite."""
+    msgs = _make_msgs("search_replace", 30)
+    f = detect_struggle(msgs)
+    assert f is not None
+    assert "write_file" in f.directive
+    assert "overwrite" in f.directive
+
+
+def test_struggle_gentle_directive_below_30() -> None:
+    """Below 30, directive is the gentle nudge (no overwrite mention)."""
+    msgs = _make_msgs("search_replace", 22)
+    f = detect_struggle(msgs)
+    assert f is not None
+    assert "overwrite" not in f.directive
+    assert "commit to a plan" in f.directive
+
+
+def test_struggle_no_fire_below_threshold() -> None:
+    msgs = _make_msgs("write_file", 5)
+    assert detect_struggle(msgs) is None

{drydock_cli-2.7.16 → drydock_cli-2.7.18}/tests/test_truncated_arg_path_hint.py

@@ -92,3 +92,33 @@ class TestTruncatedArgPathHint:
         assert len(result.failed_calls) == 1
         assert "Re-read" not in result.failed_calls[0].error
         assert "_truncated" in result.failed_calls[0].error or "truncated" in result.failed_calls[0].error
+
+    def test_existing_file_content_embedded(self, tmp_path):
+        """When the target file exists, its content is embedded in the error
+        so the model can rewrite without an extra read_file round-trip."""
+        target = tmp_path / "utils.py"
+        target.write_text("def hello():\n    return 42\n")
+
+        handler = APIToolFormatHandler()
+        parsed = ParsedMessage(
+            tool_calls=[
+                ParsedToolCall(
+                    tool_name="write_file",
+                    call_id="tc4",
+                    raw_args={
+                        "_truncated": True,
+                        "_original_bytes": 4096,
+                        "file_path": str(target),
+                    },
+                )
+            ]
+        )
+        tm = _make_tool_manager_with("write_file", _make_write_file_class())
+        result = handler.resolve_tool_calls(parsed, tm)
+        assert len(result.failed_calls) == 1
+        err = result.failed_calls[0].error
+        # Content should be embedded, not just a Re-read directive
+        assert "def hello():" in err
+        assert "return 42" in err
+        # Re-read advisory should NOT appear when content is embedded
+        assert "Re-read" not in err