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

drydock_cli-2.7.19/.auto_release.lock

@@ -0,0 +1 @@
+361748

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.7.18
+Version: 2.7.19
 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.19}/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.19}/pyproject.toml

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

drydock_cli-2.7.19/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.19}/trip_log.md

@@ -3,6 +3,22 @@
 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 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 +482,22 @@ 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

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

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

drydock_cli-2.7.18/.auto_release.lock

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