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

drydock_cli-2.7.20/.auto_release.lock

@@ -0,0 +1 @@
+404218

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.7.18
+Version: 2.7.20
 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.18 → drydock_cli-2.7.20}/drydock/core/llm/format.py

@@ -169,6 +169,11 @@ class ResolvedMessage(BaseModel):
 
 
 class APIToolFormatHandler:
+    def __init__(self) -> None:
+        # Track per-path truncated-history write_file retries so we can
+        # escalate on 2nd+ identical failures (model ignores advisory-only msgs).
+        self._truncated_hit_count: dict[str, int] = {}
+
     @property
     def name(self) -> str:
         return "api"
@@ -379,6 +384,12 @@ class APIToolFormatHandler:
                 path_hint = (parsed_call.raw_args.get("path")
                              or parsed_call.raw_args.get("file_path")
                              or "")
+                # Track retry count per path to escalate on 2nd+ offense.
+                hit_key = path_hint or "<unknown>"
+                hit_count = self._truncated_hit_count.get(hit_key, 0) + 1
+                self._truncated_hit_count[hit_key] = hit_count
+                escalate = hit_count >= 2
+
                 # Auto-embed the current file content so the model can
                 # rewrite immediately without an extra read_file round-trip.
                 file_embed = ""
@@ -407,6 +418,31 @@ class APIToolFormatHandler:
                         pass
                 if not file_embed and path_hint:
                     file_embed = f" Re-read `{path_hint}` with read_file first."
+
+                if escalate:
+                    # Model is stuck in a truncated-template retry loop.
+                    # Show project files and give a concrete directive.
+                    try:
+                        py_files = sorted(
+                            str(p2.relative_to(Path.cwd()))
+                            for p2 in Path.cwd().rglob("*.py")
+                            if "__pycache__" not in str(p2) and ".git" not in str(p2)
+                        )[:20]
+                        dir_listing = "\n".join(f"  {f}" for f in py_files)
+                    except Exception:
+                        dir_listing = "  (could not list files)"
+                    escalation_suffix = (
+                        f"\n\n[REPEATED FAILURE #{hit_count}: your write_file call "
+                        f"keeps using a stale truncated template for '{path_hint}'. "
+                        f"You MUST type fresh content — do NOT copy from history. "
+                        f"Current .py files in project:\n{dir_listing}\n"
+                        f"Use read_file on the target file, then call write_file "
+                        f"with fully typed content, OR use search_replace to make "
+                        f"targeted edits without rewriting the whole file.]"
+                    )
+                else:
+                    escalation_suffix = ""
+
                 failed_calls.append(
                     FailedToolCall(
                         tool_name=parsed_call.tool_name,
@@ -415,7 +451,8 @@ class APIToolFormatHandler:
                             f"your call used a "
                             f"truncated history entry as a template (it contained "
                             f"'_truncated'/'_original_bytes' instead of real "
-                            f"arguments).{file_embed} Provide the full required arguments."
+                            f"arguments).{file_embed} Provide the full required "
+                            f"arguments.{escalation_suffix}"
                         ),
                     )
                 )

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

@@ -111,19 +111,29 @@ class ReadFile(
             and prior.get("offset") == args.offset
             and prior.get("limit") == args.limit
         ):
+            # Re-embed the cached content so the model has it even if the
+            # earlier tool_result was truncated by _truncate_old_tool_results.
+            # Pointing at a stale/truncated prior result causes re-read loops.
+            cached_content = prior.get("content", "")
+            prior_lines = prior.get("lines_read", 0)
+            dedup_count = prior.get("dedup_count", 0)
+            if dedup_count == 0:
+                header = "[Unchanged since last read — content re-embedded]\n"
+            else:
+                header = (
+                    f"[REPEATED READ #{dedup_count + 1}: file has not changed across your last "
+                    f"{dedup_count + 1} reads with these exact arguments. "
+                    f"Reading again will produce this same result. "
+                    f"To make progress: write or edit a file, use offset= to read a different section, "
+                    f"or move on to the next task.]\n"
+                )
+            if read_state is not None:
+                read_state[path_key] = {**prior, "dedup_count": dedup_count + 1}
             yield ReadFileResult(
                 path=path_key,
-                content=(
-                    "<system-reminder>\n"
-                    f"File unchanged since your earlier read this session "
-                    f"({file_path.name}, mtime unchanged, same offset/limit). "
-                    "Use the content from the earlier Read tool_result — "
-                    "do NOT re-read. If you need to take action, call "
-                    "search_replace or write_file on what you already have.\n"
-                    "</system-reminder>"
-                ),
-                lines_read=0,
-                was_truncated=True,
+                content=f"{header}{cached_content}",
+                lines_read=prior_lines,
+                was_truncated=prior.get("was_truncated", False),
             )
             return
 
@@ -151,6 +161,8 @@ class ReadFile(
                 "timestamp": current_mtime,
                 "offset": args.offset,
                 "limit": args.limit,
+                "lines_read": len(read_result.lines),
+                "was_truncated": read_result.was_truncated,
             }
 
         yield ReadFileResult(

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

@@ -175,17 +175,46 @@ class SearchReplace(
                 # 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.
+                # Track consecutive calls to escalate guidance on 2nd+ offense.
                 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():
+                    dir_state = self.state.__dict__.setdefault("_sr_dir_history", {})
+                    dir_key = str(dir_path)
+                    dir_entry = dir_state.get(dir_key, {"count": 0})
+                    dir_entry["count"] += 1
+                    dir_state[dir_key] = dir_entry
+                    dir_count = dir_entry["count"]
                     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)"
+                    if dir_count >= 2:
+                        # Escalate: model retried the same directory path — add project listing
+                        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]
+                            project_listing = (
+                                f"\n[REPEATED ERROR #{dir_count}: you have called search_replace on "
+                                f"this directory {dir_count} times. You MUST specify a filename. "
+                                f"Project .py files:\n"
+                                + "\n".join(f"  {f}" for f in py_files)
+                                + "\nUse the exact path from this list.]"
+                            )
+                        except Exception:
+                            project_listing = (
+                                f"\n[REPEATED ERROR #{dir_count}: stop passing the directory. "
+                                "Use a full file path like 'tool_agent/cli.py'.]"
+                            )
+                    else:
+                        project_listing = ""
                     yield SearchReplaceResult(
                         file=str(dir_path),
                         blocks_applied=0,
@@ -195,7 +224,8 @@ class SearchReplace(
                             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>'"
+                            f"'{dir_path}/{files[0] if files else '<filename.py>'}'"
+                            + project_listing
                         ),
                     )
                     return

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

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "2.7.18"
+version = "2.7.20"
 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 → drydock_cli-2.7.20}/scripts/stress_babysitter.sh

@@ -28,8 +28,8 @@ PID_FILE=/tmp/stress_pid.txt
 # /tmp/stress_2000_*.log. Avoids the stale-log bug where babysitter reported
 # COMPLETE for hours while the real harness kept processing (2026-04-25).
 # Falls back to the prior hardcoded path if no match exists yet.
-STRESS_LOG=$(ls -t /tmp/stress_2000_*.log 2>/dev/null | head -1)
-STRESS_LOG=${STRESS_LOG:-/tmp/stress_2000_v10_restart_1777237201.log}
+STRESS_LOG=/tmp/stress_2000_v10_restart_1777453487.log
+STRESS_LOG=/tmp/stress_2000_v10_restart_1777453487.log
 NOTIFY=/data3/drydock/scripts/notify_release.py
 PY_CONDA=/home/bobef/miniconda3/bin/python3
 PY_DRYDOCK=/home/bobef/miniforge3/envs/drydock/bin/python3

drydock_cli-2.7.20/tests/test_truncated_write_escalation.py

@@ -0,0 +1,104 @@
+"""Regression test: truncated write_file retry loop escalation.
+
+When Gemma 4 calls write_file with _truncated args (copied from a pruned history
+entry), drydock returns a FailedToolCall. The model often retries identically
+instead of correcting the call, creating an 8-10 turn loop (observed in stress run
+2026-04-29, ~8 fires of retry_after_error:write_file:truncated history in 7 min).
+
+Fix: APIToolFormatHandler tracks per-path truncated-arg hit count.  On the 2nd+
+identical failure for the same path, the error message is escalated with a project
+file listing and a concrete directive to type fresh content or use search_replace.
+"""
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+from drydock.core.llm.format import APIToolFormatHandler, ParsedMessage, ParsedToolCall
+from drydock.core.tools.builtins.write_file import WriteFile
+
+
+def _make_tm():
+    tm = MagicMock()
+    tm.available_tools = {"write_file": WriteFile}
+    return tm
+
+
+def _truncated_call(path: str, call_id: str = "tc1") -> ParsedMessage:
+    return ParsedMessage(
+        tool_calls=[
+            ParsedToolCall(
+                tool_name="write_file",
+                call_id=call_id,
+                raw_args={
+                    "_truncated": True,
+                    "_original_bytes": 4096,
+                    "file_path": path,
+                },
+            )
+        ]
+    )
+
+
+class TestTruncatedWriteEscalation:
+    def test_first_hit_no_escalation(self, tmp_path):
+        """First truncated-arg failure returns normal advisory, no escalation block."""
+        target = tmp_path / "cli.py"
+        target.write_text("print('hello')\n")
+        handler = APIToolFormatHandler()
+        result = handler.resolve_tool_calls(_truncated_call(str(target)), _make_tm())
+        err = result.failed_calls[0].error
+        assert "REPEATED FAILURE" not in err
+        assert "truncated" in err.lower()
+
+    def test_second_hit_escalates(self, tmp_path):
+        """Second truncated-arg failure for the same path triggers escalation block."""
+        target = tmp_path / "cli.py"
+        target.write_text("print('hello')\n")
+        handler = APIToolFormatHandler()
+        # First call
+        handler.resolve_tool_calls(_truncated_call(str(target), "tc1"), _make_tm())
+        # Second call — should escalate
+        result = handler.resolve_tool_calls(_truncated_call(str(target), "tc2"), _make_tm())
+        err = result.failed_calls[0].error
+        assert "REPEATED FAILURE #2" in err
+        assert "stale truncated template" in err
+        assert "search_replace" in err
+
+    def test_third_hit_increments_count(self, tmp_path):
+        """Third hit shows #3 in the escalation message."""
+        target = tmp_path / "utils.py"
+        target.write_text("x = 1\n")
+        handler = APIToolFormatHandler()
+        for i in range(3):
+            result = handler.resolve_tool_calls(
+                _truncated_call(str(target), f"tc{i}"), _make_tm()
+            )
+        err = result.failed_calls[0].error
+        assert "REPEATED FAILURE #3" in err
+
+    def test_different_paths_tracked_separately(self, tmp_path):
+        """Two different paths each have their own hit counter."""
+        a = tmp_path / "a.py"
+        b = tmp_path / "b.py"
+        a.write_text("pass\n")
+        b.write_text("pass\n")
+        handler = APIToolFormatHandler()
+        # Hit path a twice → escalate
+        handler.resolve_tool_calls(_truncated_call(str(a), "tc1"), _make_tm())
+        result_a = handler.resolve_tool_calls(_truncated_call(str(a), "tc2"), _make_tm())
+        assert "REPEATED FAILURE #2" in result_a.failed_calls[0].error
+        # Hit path b once → no escalation
+        result_b = handler.resolve_tool_calls(_truncated_call(str(b), "tc3"), _make_tm())
+        assert "REPEATED FAILURE" not in result_b.failed_calls[0].error
+
+    def test_fresh_handler_resets_count(self, tmp_path):
+        """A new APIToolFormatHandler instance starts with a clean counter."""
+        target = tmp_path / "main.py"
+        target.write_text("pass\n")
+        handler1 = APIToolFormatHandler()
+        handler1.resolve_tool_calls(_truncated_call(str(target), "tc1"), _make_tm())
+        handler1.resolve_tool_calls(_truncated_call(str(target), "tc2"), _make_tm())
+        # Fresh handler for a new session — no accumulated state
+        handler2 = APIToolFormatHandler()
+        result = handler2.resolve_tool_calls(_truncated_call(str(target), "tc3"), _make_tm())
+        assert "REPEATED FAILURE" not in result.failed_calls[0].error

drydock_cli-2.7.20/tests/tools/test_read_file_dedup_reembed.py

@@ -0,0 +1,136 @@
+"""Regression test: read_file dedup re-embeds cached content instead of pointing
+at a possibly-truncated prior tool_result.
+
+The model (Gemma 4) looped re-reading cli.py with limit=100 because:
+1. First read: stored in read_state, returned truncated content.
+2. _truncate_old_tool_results pruned that tool_result from message history.
+3. Second read (same offset/limit/mtime): dedup fired with "use earlier result."
+4. Model couldn't find the earlier result (truncated) and re-read again → loop.
+
+Fix: when dedup fires, embed the cached content directly in the response
+rather than pointing at the prior (possibly absent) tool_result.
+"""
+from __future__ import annotations
+
+import pytest
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from drydock.core.tools.base import BaseToolState
+from drydock.core.tools.builtins.read_file import ReadFile, ReadFileArgs, ReadFileResult, ReadFileToolConfig
+
+
+async def _run_result(tool, args, ctx) -> ReadFileResult:
+    async for event in tool.run(args, ctx):
+        if isinstance(event, ReadFileResult):
+            return event
+    raise AssertionError("no ReadFileResult yielded")
+
+
+@pytest.mark.asyncio
+async def test_dedup_reembeds_cached_content(tmp_path):
+    """Second identical read returns cached content, not a pointer stub."""
+    f = tmp_path / "cli.py"
+    f.write_text("def main():\n    pass\n")
+
+    tool = ReadFile(ReadFileToolConfig(), BaseToolState())
+    read_state: dict = {}
+    ctx = MagicMock()
+    ctx.read_file_state = read_state
+
+    args = ReadFileArgs(path=str(f), offset=0, limit=100)
+
+    # First read populates the cache.
+    result1 = await _run_result(tool, args, ctx)
+    assert "def main" in result1.content
+
+    # Second read with same args/mtime must return real content, not a pointer.
+    result2 = await _run_result(tool, args, ctx)
+    assert "def main" in result2.content, "dedup must re-embed content, not point at prior result"
+    assert "re-embedded" in result2.content
+
+
+@pytest.mark.asyncio
+async def test_dedup_does_not_fire_after_file_changes(tmp_path):
+    """Dedup must not fire if the file has been modified on disk."""
+    f = tmp_path / "cli.py"
+    f.write_text("version = 1\n")
+
+    tool = ReadFile(ReadFileToolConfig(), BaseToolState())
+    read_state: dict = {}
+    ctx = MagicMock()
+    ctx.read_file_state = read_state
+
+    args = ReadFileArgs(path=str(f), offset=0, limit=100)
+
+    result1 = await _run_result(tool, args, ctx)
+    assert "version = 1" in result1.content
+
+    # Modify the file (mtime changes).
+    import time; time.sleep(0.01)
+    f.write_text("version = 2\n")
+
+    result2 = await _run_result(tool, args, ctx)
+    assert "version = 2" in result2.content, "should read updated file, not cached content"
+    assert "re-embedded" not in result2.content
+
+
+@pytest.mark.asyncio
+async def test_dedup_escalates_on_repeated_reads(tmp_path):
+    """Third and later identical reads get an escalating REPEATED READ advisory."""
+    f = tmp_path / "cli.py"
+    f.write_text("def main():\n    pass\n")
+
+    tool = ReadFile(ReadFileToolConfig(), BaseToolState())
+    read_state: dict = {}
+    ctx = MagicMock()
+    ctx.read_file_state = read_state
+
+    args = ReadFileArgs(path=str(f), offset=0, limit=100)
+
+    # First read: no dedup.
+    r1 = await _run_result(tool, args, ctx)
+    assert "re-embedded" not in r1.content
+    assert "REPEATED READ" not in r1.content
+
+    # Second read: first dedup hit — gentle re-embed message.
+    r2 = await _run_result(tool, args, ctx)
+    assert "re-embedded" in r2.content
+    assert "REPEATED READ" not in r2.content
+    assert read_state[str(f)]["dedup_count"] == 1
+
+    # Third read: second dedup hit — escalated advisory.
+    r3 = await _run_result(tool, args, ctx)
+    assert "REPEATED READ #2" in r3.content
+    assert "def main" in r3.content
+    assert read_state[str(f)]["dedup_count"] == 2
+
+    # Fourth read: third dedup hit — counter increments.
+    r4 = await _run_result(tool, args, ctx)
+    assert "REPEATED READ #3" in r4.content
+    assert read_state[str(f)]["dedup_count"] == 3
+
+
+@pytest.mark.asyncio
+async def test_dedup_stores_lines_read_and_was_truncated(tmp_path):
+    """read_state must record lines_read and was_truncated for correct dedup re-embedding."""
+    f = tmp_path / "big.py"
+    f.write_text("\n".join(f"line{i}" for i in range(1, 201)))  # 200 lines
+
+    tool = ReadFile(ReadFileToolConfig(), BaseToolState())
+    read_state: dict = {}
+    ctx = MagicMock()
+    ctx.read_file_state = read_state
+
+    args = ReadFileArgs(path=str(f), offset=0, limit=50)
+    await _run_result(tool, args, ctx)
+
+    path_key = str(f)
+    assert "lines_read" in read_state[path_key]
+    assert read_state[path_key]["lines_read"] == 50
+    assert read_state[path_key]["was_truncated"] is True
+
+    # Second read: dedup fires, re-embeds with correct metadata.
+    result2 = await _run_result(tool, args, ctx)
+    assert result2.lines_read == 50
+    assert result2.was_truncated is True

{drydock_cli-2.7.18 → drydock_cli-2.7.20}/tests/tools/test_search_replace_dir_path.py

@@ -89,3 +89,26 @@ async def test_directory_path_repeated_call_still_returns_result(tool, ctx, tmp_
         assert isinstance(result, SearchReplaceResult)
         assert result.blocks_applied == 0
         assert "PATH ERROR" in result.content
+
+
+@pytest.mark.asyncio
+async def test_directory_path_escalates_on_second_call(tool, ctx, tmp_path):
+    """Second call with the same directory path includes REPEATED ERROR escalation."""
+    (tmp_path / "cli.py").write_text("x = 1\n")
+    args = SearchReplaceArgs(
+        file_path=str(tmp_path),
+        content="<<<<<<< SEARCH\nold\n=======\nnew\n>>>>>>> REPLACE",
+    )
+    # First call — no escalation
+    results1 = await _collect(tool.run(args, ctx))
+    assert "REPEATED ERROR" not in results1[-1].content
+
+    # Second call — escalation fires
+    results2 = await _collect(tool.run(args, ctx))
+    assert "REPEATED ERROR" in results2[-1].content
+    assert "#2" in results2[-1].content
+
+    # Third call — escalation still present with updated count
+    results3 = await _collect(tool.run(args, ctx))
+    assert "REPEATED ERROR" in results3[-1].content
+    assert "#3" in results3[-1].content

{drydock_cli-2.7.18 → drydock_cli-2.7.20}/trip_log.md

@@ -3,6 +3,38 @@
 Autonomous Claude Code review ticks while the user is away. Each tick appended
 chronologically. Cron-driven every 30 min from `/data3/drydock/scripts/autonomous_review.sh`.
 
+## 2026-04-29 08:34 UTC tick
+- Stress: 229/1658 (PID 270529, new run started ~Apr 29 03:26 UTC; progressing)
+- Write rate: 19% (last 100 prompts) — early in sequence; previous run was at 73% at prompts 1550-1650, not a fair comparison; new run at prompt 225 already has 52 writes vs 0 in prev run at same point, so actually running better
+- Admiral last 30 min: struggle:66-76 (model made 76 reads without writing; ended on its own); loop:bash --help x1; retry_after_error:search_replace directory path x1; empty_after_tool:read_file x1 — all known model-behavior patterns
+- vLLM 400s: 0
+- GH issues: 0 open
+- Action this tick: no fix committed; b2f26aa (search_replace dir-path escalation) is unshipped pending next auto_release at ~12:00 UTC; skip rate 24% is higher than prev run's 7% at same point but this is variance from model being in 76-read struggle sessions, not a drydock bug
+
+## 2026-04-29 08:01 UTC tick
+- Stress: 207/1658 (PID 270529, new run from babysitter restart; progressing normally)
+- Write rate: 15% (expected — prompts 200-207 are analysis queries: function_count, class_count, test_file_count, etc., no file writes expected)
+- Admiral last 30 min: struggle events firing at 70+ consecutive non-write tool calls; empty_after_tool:read_file x4 (all handled by stall retry); one empty_after_tool:web_search — all normal model-behavior noise
+- vLLM 400s: 0
+- GH issues: 0 open
+- Action this tick: No fix committed. All systems healthy. Commit b2f26aa (search_replace: escalate directory-path error on 2nd+ repeated call) is staged ahead of v2.7.19 tag, will auto-release as v2.7.20 at 12:00 UTC.
+
+## 2026-04-29 06:10 UTC tick
+- Stress: 141/1658 (PID 270529, new run started by babysitter; prior run PID 3713698 dead)
+- Write rate: 38% (significant regression from 74% sustained — SKIP rate 44% vs 13% baseline in prior run)
+- Admiral last 30 min: loop:bash, loop:search_replace, loop:read_file, struggle:search_replace all firing — normal model-behavior noise
+- vLLM 400s: 0
+- GH issues: 0 open
+- Action this tick: No fix committed. Investigated SKIP regression: 62/141 prompts skipped with "TUI did not accept after 3 retries". SKIPs began at prompt 10 in the very first session. Pattern suggests TUI is busy processing previous turn output when harness sends next prompt; watcher times out after 3×120s without seeing new user message in session log. v2.7.18 read_file escalation changes (2nd+ identical dedup escalates with full context) may be causing model to stay in extended tool-call loops after each turn "completes", keeping the session non-quiet. No actionable drydock source fix identified within budget — flagged for user to investigate on return (2026-05-01).
+
+## 2026-04-29 04:35 UTC tick
+- Stress: 128/1658 (new run restarted by babysitter; prior run PID 3713698 dead at 680/1658)
+- Write rate: 39% (was 74% sustained — SKIP rate elevated at ~30% vs 8% baseline)
+- Admiral last 30 min: active — loop:read_file(tool_agent/cli.py, limit=100) firing repeatedly; struggle:search_replace counts reaching 30-36 per prompt
+- vLLM 400s: 0
+- GH issues: 0 open
+- Action this tick: triggered manual auto_release to ship v2.7.18 early (tagged, PyPI upload confirmed). The 4 unreleased commits (read_file pagination hint, search_replace empty-content soft advisory, write_file dir-path detection, write_file path inference) directly address the read_file loop pattern visible in admiral logs: model reads cli.py with limit=100, gets no truncation hint, retries identically 3+ times, then struggles with search_replace on text it couldn't see. v2.7.18 adds the pagination hint that breaks this cycle. Stress run is live at 128/1658 and will pick up v2.7.18 at next session reset.
+
 **Pause loop:** `touch /data3/drydock/.pause_autonomous_loop`
 **Resume loop:** `rm /data3/drydock/.pause_autonomous_loop`
 **Live log:** `/data3/drydock/logs/autonomous_review.log` (full Claude output + errors)
@@ -466,3 +498,91 @@ restarted, cron self-match bug fixed in this same session).
 - GH issues: 0 open
 - Services: llm_balancer PID 24354 on :8001 healthy, vLLM gemma4 up, balancer curl verified
 - Action this tick: committed fix (11f1752) — search_replace empty-content ToolError converted to soft advisory SearchReplaceResult; tracks consecutive empty-content calls per file and escalates with project file listing on 2nd+ offense; 3 regression tests added; auto-ships as v2.7.18 at next 06:00 UTC cron tick
+
+## 2026-04-29 05:10 UTC tick
+- Stress: 132/1658 (new run, PID 270529, log /tmp/stress_2000_1777408317.log, 8.5h elapsed)
+- Write rate: 40% (last 65 prompts)
+- SKIP rate: 55/132 (42%) — TUI queuing stress prompts while busy; harness detection mismatch, not a drydock bug
+- Admiral last 30 min: loop:read_file (cli.py, limit=100) ~6 fires, struggle:search_replace ~10 fires, empty_after_tool 2 fires
+- vLLM 400s: 0
+- GH issues: 0 open
+- Action this tick: committed fix(read_file): re-embed cached content on dedup — when _truncate_old_tool_results pruned the earlier tool_result, the dedup stub pointed at absent content causing re-read loops; now embeds cached content directly. 3 regression tests added. Will ship at next 0/6/12/18 UTC auto-release tick.
+
+## 2026-04-29 05:50 UTC tick
+- Stress: 137/1658 (PID 270529 alive, new run restarted from 0 since previous tick; babysitter keeps it alive)
+- Write rate: 32% (last 50 completed prompts; low due to high SKIP rate and lightweight utility prompts)
+- SKIP rate: 66/137 = 48% (elevated; concentrated in timezone/date-util prompts where TUI is busy with prior session)
+- Admiral last 30 min: 25 fires — loop:read_file::cli.py(limit=100) dominant (30+ occurrences across session), struggle:search_replace, empty_after_tool all known patterns
+- vLLM 400s: 0
+- GH issues: 0 open
+- Services: llm_balancer PID 24354 on :8001 healthy, vLLM gemma4 container up, stress harness PID 270529 running
+- Action this tick: committed fix(read_file) ff5217d — escalating REPEATED READ #N advisory on 2nd+ identical dedup read; 1 new regression test (4 total in test file pass); auto-ships at next 0/6/12/18 UTC tick
+
+## 2026-04-29 06:40 UTC tick
+- Stress: 146/1658 (PID 270529 alive; new run restarted from 0 by babysitter; old run 3713698 gone)
+- Write rate: 26/67 = 38% (last 100 completed prompts)
+- SKIP rate: 45/141 = 32% — TUI busy; FORCE-RESETs unsticking; known pattern
+- Admiral last 30 min: struggle:search_replace (27-46 calls, single long session at 06:05-06:07 UTC); loop:read_file::cli.py(limit=100) and loop:search_replace at 06:28-06:31 UTC; empty_after_tool:read_file 1 fire
+- vLLM 400s: 0
+- GH issues: 0 open
+- Services: llm_balancer PID 24354 on :8001 healthy, vLLM gemma4 up, stress harness PID 270529 running
+- Action this tick: triggered manual auto_release (v2.7.19) to ship read_file dedup fixes (ff5217d, 3fc4e4b) committed earlier this session but missed by midnight cron; PyPI upload OK; installed wheel directly into user's env; all prior fixes (search_replace HARD-STOP loop-breaker, dedup re-embed, escalating dedup advisory) now live
+
+## 2026-04-29 07:03 UTC tick
+- Stress: 149/1658 (PID 270529 alive, new run; babysitter restarted from 0 at ~00:30 UTC)
+- Write rate: 38% overall (26/67 completed prompts), 32% last 50; lightweight utility prompts at start of run
+- SKIP rate: ~45% (TUI busy; FORCE-RESETs happening; known harness/TUI timing mismatch)
+- Admiral last 30 min: struggle:search_replace (35-call streak), loop:read_file::cli.py, loop:search_replace (identical blocks), retry_after_error:search_replace (directory path)
+- vLLM 400s: 0
+- GH issues: 0 open
+- Services: llm_balancer PID 24354 on :8001 healthy, vLLM gemma4 up, stress PID 270529 running
+- Action this tick: committed fix(search_replace) b2f26aa — escalate directory-path error on 2nd+ repeat; model was getting same PATH ERROR advisory each time and retrying indefinitely; now get REPEATED ERROR #N + full project .py listing on 2nd+ offense; 4 regression tests (all pass); auto-ships at next 0/6/12/18 UTC auto-release tick
+
+## 2026-04-29 07:33 UTC tick
+- Stress: 680/1658 (41%; PID 270529 alive, 11h elapsed)
+- Write rate: 32% last 100 prompts (down from 74% peak); prompt section now at "API: WebSocket/SSE/JSON-RPC/gRPC" + tool-existence queries — model explores codebase but writes 0 files for most; expected given prompt difficulty
+- SKIP rate: 80 total SKIPs; prompts 677-679 SKIPped consecutively after 21-msg/7-write WebSocket session; harness FORCE-RESET unstuck it; prompt 680 currently in progress
+- Admiral last 30 min: struggle:40-70 tool calls without writes (multiple interventions 07:23-07:30 UTC); model reading extensively for API-type prompts; admiral correctly firing; no new admiral pattern
+- vLLM 400s: 0
+- GH issues: 0 open
+- Services: llm_balancer PID 24354 on :8001 healthy (confirmed curl), vLLM gemma4 up, stress PID 270529 running, admiral_probe PID 4075121 on :8878
+- Unshipped: b2f26aa (search_replace dir-path escalation) will ship at next auto-release ~11:00 UTC
+- Action this tick: no action — system healthy; write rate dip is prompt-section artifact (API/question prompts), not a drydock regression; no new bugs found
+
+## 2026-04-29 09:15 UTC tick
+- Stress: 232/1658 (PID 270529 was stuck for 5+ hours; killed and restarted as PID 387049 resuming from step 175)
+- Write rate: 19% last 100 prompts (expected — prompts 1-232 are single-word CLI invocations, not write tasks)
+- SKIP rate: 24% (55 skips at idx=232; consistent with early-run pattern, normalizes over time)
+- Admiral last 30 min: loop:bash::--help, retry_after_error:bash, loop:read_file::cli.py(limit=100), retry_after_error:search_replace (directory path repeats); all normal patterns
+- vLLM 400s: 0
+- GH issues: 0 open
+- Services: llm_balancer healthy on :8001, vLLM gemma4 healthy (Running: 0 reqs), stress harness PID 387049 resuming from step 175
+- Action this tick: killed stuck harness PID 270529 (TUI child 270531 was stuck in "Observing..." for 5h with no model response; vLLM healthy so likely pexpect stream deadlock); restarted via babysitter which resumed from checkpoint 173 at step 175; harness now progressing again
+
+## 2026-04-29 09:33 UTC tick
+- Stress: 215/1658 (PID 387049 alive, 29 min elapsed, 260MB RSS; prior run COMPLETED 1658/1658 on 2026-04-28 20:00 UTC; babysitter restarted fresh run at 09:04 UTC after PID 270527 died at idx=233)
+- Write rate: 5% last 39 prompts (analysis-prompt section 196-215: lines_of_code, tabs_vs_spaces, indent_consistency_check etc. — all expected 0 writes; model actively writing files again from prompt 212 onward: ethereum_price.py, ip_geolocation.py, phone_to_country.py confirmed in session log)
+- Admiral last 30 min: 0 fires since 09:04 restart; prior session had loop:bash::--help, loop:read_file::cli.py, retry_after_error:search_replace (directory path) — all known patterns
+- vLLM 400s: 0
+- GH issues: 0 open
+- Services: llm_balancer healthy on :8001, vLLM gemma4 running, admiral_probe up; stress babysitter STRESS_LOG has cosmetic duplicate line (both set to current log, harmless)
+- Unshipped: b2f26aa (search_replace escalate directory-path error on 2nd+ call) ships at ~11:00 UTC as v2.7.20
+- Action this tick: no action — system healthy; prior stress run completed full 1658-prompt sweep; new run progressing normally; no new bugs found
+
+## 2026-04-29 10:03 UTC tick
+- Stress: 230/1658 (PID 387049 alive, started 09:04 UTC, resumed from step 174; prior full run at 680/1658 was from old log /tmp/stress_2000_1777119799.log — current active log is /tmp/stress_2000_v10_restart_1777453487.log)
+- Write rate: 28% (15/52 prompts with writes in current run; low-write section 174-230 includes analysis/sentiment/keyword prompts with minimal file creation)
+- vLLM 400s: 0 (89% prefix cache hit rate, GPU healthy)
+- GH issues: 0 open
+- Services: llm_balancer PID 24354 on :8001 healthy, vLLM gemma4 up, admiral_probe up; babysitter STRESS_LOG correctly pointed at active log
+- Unshipped: b2f26aa (search_replace escalate dir-path error on 2nd+ call) ships at 12:00 UTC as v2.7.20
+- Admiral patterns last 2h: retry_after_error:write_file (truncated-history recovery) x2 — investigated; model correctly recovered by resubmitting with real args, write succeeded; no new drydock bug; empty_after_tool:search_replace x1, retry_after_error:bash, retry_after_error:search_replace — all known patterns
+- Action this tick: no fix committed — all services healthy, no new bugs found; previous stress log confusion resolved (was reading old Apr 26 log instead of current babysitter log)
+
+## 2026-04-29 10:35 UTC tick
+- Stress: 235/1658 (PID 387049 alive, 1h25m elapsed, resuming from step 174; current prompts are qr_encode/decode/barcode_encode section, mostly TIMEOUT with writes)
+- Write rate: 33% last 56 prompts (19/56 with writes; analysis/QR section skews low)
+- vLLM 400s: 0
+- GH issues: 0 open
+- Services: llm_balancer healthy, vLLM gemma4 up, stress harness alive
+- Action this tick: committed fix 3695f6b — escalate truncated-history write_file retry on 2nd+ offense. Pattern observed: 8 consecutive retry_after_error:write_file:truncated_history fires in 7 min (10:05-10:12 UTC), model ignoring the existing advisory. APIToolFormatHandler now tracks per-path hit count; 2nd+ failure gets "REPEATED FAILURE #N" with project file listing and concrete search_replace alternative, matching the escalation pattern in search_replace.py. 5 regression tests pass. Ships as v2.7.21 at next auto-release (~12:00 UTC).

{drydock_cli-2.7.18 → drydock_cli-2.7.20}/uv.lock

@@ -326,7 +326,7 @@ wheels = [
 
 [[package]]
 name = "drydock-cli"
-version = "2.7.17"
+version = "2.7.19"
 source = { editable = "." }
 dependencies = [
     { name = "agent-client-protocol" },

drydock_cli-2.7.18/.auto_release.lock

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