drydock-cli 2.9.105__tar.gz → 2.9.109__tar.gz

{drydock_cli-2.9.105 → drydock_cli-2.9.109}/PKG-INFO

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

{drydock_cli-2.9.105 → drydock_cli-2.9.109}/drydock/core/agent_loop.py

@@ -3242,65 +3242,66 @@ class AgentLoop:
                     )
                 return
 
-        # 2026-06-07 Pre-flight: prune duplicate write_file history (v2.9.104).
-        # User session 2026-06-06 v2.9.95 batch `sam-cell-seg` trial:
-        # 22 identical writes to `/app/conversation_summary.smd` with the
-        # same sha8=d3bedbf3 content. The existing write_file dedup is
-        # advisory-only (per feedback_no_tool_errors_for_loop_detection.md)
-        # and Gemma 4 ignores the advisory. Same architectural fix as the
-        # consecutive-task preflight: drop the old duplicate calls from
-        # history so the model's next turn sees a cleaner context, with
-        # only the most recent attempt visible. Tool itself stays advisory.
-        if tool_call.tool_name == "write_file":
-            try:
-                cur_path = (
-                    tool_call.args_dict.get("path")
-                    or tool_call.args_dict.get("file_path")
-                    or ""
+        # 2026-06-07 Pre-flight: prune duplicate tool-call history
+        # (v2.9.104 write_file-specific; v2.9.108 generalized to any tool).
+        # Multiple user-observed loops where Gemma 4 emits the EXACT same
+        # tool name + args 5+ times in a row, each producing the same
+        # no-op result, ignoring the advisory:
+        #   2026-06-06 v2.9.95 sam-cell-seg: 22 writes to same path, same
+        #     content (sha8=d3bedbf3).
+        #   2026-06-06 v2.9.95 distribution-search: 3 identical
+        #     solve(p1:Real, p2:Real, conclusion:True, objective:"") calls
+        #     ending the trial.
+        # Tool-level dedup is advisory-only by design (per memory file
+        # feedback_no_tool_errors_for_loop_detection.md) and the model
+        # ignores advisories.
+        #
+        # Architectural fix: at preflight, if the current call is the
+        # 5th+ identical (same name + same args) call in history, prune
+        # the older N-1 duplicates (and their tool-result siblings) so
+        # the model's next turn sees a clean context. Exact-args match
+        # only — partial overlap doesn't count, since e.g. read_file
+        # with different offsets is legitimate progress.
+        try:
+            cur_name = tool_call.tool_name
+            cur_args_json = json.dumps(
+                tool_call.args_dict, sort_keys=True, default=str
+            )
+            dup_indices: list[int] = []
+            for i, m in enumerate(self.messages):
+                if m.role != Role.assistant or not m.tool_calls:
+                    continue
+                for tc in m.tool_calls:
+                    if tc.function.name != cur_name:
+                        continue
+                    try:
+                        a = json.loads(tc.function.arguments or "{}")
+                    except Exception:
+                        continue
+                    if json.dumps(a, sort_keys=True, default=str) == cur_args_json:
+                        dup_indices.append(i)
+                        break
+            dup_count = len(dup_indices)
+            if dup_count >= 5 and len(dup_indices) > 1:
+                to_drop = set()
+                for idx in dup_indices[:-1]:
+                    to_drop.add(idx)
+                    if idx + 1 < len(self.messages):
+                        next_m = self.messages[idx + 1]
+                        if next_m.role == Role.tool:
+                            to_drop.add(idx + 1)
+                kept = [
+                    m for i, m in enumerate(self.messages)
+                    if i not in to_drop
+                ]
+                self.messages.reset(kept)
+                logger.warning(
+                    "[PREFLIGHT-DUP] pruned %d duplicate %s calls "
+                    "(%d identical attempts in history)",
+                    len(to_drop), cur_name, dup_count,
                 )
-                cur_content = tool_call.args_dict.get("content", "")
-                if cur_path and isinstance(cur_content, str):
-                    dup_count = 0
-                    dup_indices: list[int] = []
-                    for i, m in enumerate(self.messages):
-                        if m.role != Role.assistant or not m.tool_calls:
-                            continue
-                        for tc in m.tool_calls:
-                            if tc.function.name != "write_file":
-                                continue
-                            try:
-                                a = json.loads(tc.function.arguments or "{}")
-                            except Exception:
-                                continue
-                            ap = a.get("path") or a.get("file_path") or ""
-                            ac = a.get("content", "")
-                            if ap == cur_path and ac == cur_content:
-                                dup_count += 1
-                                dup_indices.append(i)
-                                break
-                    if dup_count >= 5 and len(dup_indices) > 1:
-                        # Drop all but the most recent prior duplicate.
-                        # Also drop the tool result that immediately follows.
-                        to_drop = set()
-                        for idx in dup_indices[:-1]:
-                            to_drop.add(idx)
-                            if idx + 1 < len(self.messages):
-                                next_m = self.messages[idx + 1]
-                                if next_m.role == Role.tool:
-                                    to_drop.add(idx + 1)
-                        kept = [
-                            m for i, m in enumerate(self.messages)
-                            if i not in to_drop
-                        ]
-                        self.messages.reset(kept)
-                        logger.warning(
-                            "[PREFLIGHT-WRITE-DUP] pruned %d duplicate "
-                            "write_file calls to %r (%d identical "
-                            "attempts in history)",
-                            len(to_drop), cur_path, dup_count,
-                        )
-            except Exception as _e:
-                logger.debug("[PREFLIGHT-WRITE-DUP] failed: %s", _e)
+        except Exception as _e:
+            logger.debug("[PREFLIGHT-DUP] failed: %s", _e)
 
         # 2026-06-05 Pre-flight path validation. Operator: "why can't tool
         # calls check the right pathing BEFORE doing it?" Right answer.

{drydock_cli-2.9.105 → drydock_cli-2.9.109}/drydock/core/prompts/gemma4_slim.md

@@ -1,16 +1,16 @@
 You are DryDock, a CLI coding agent. You write code, fix bugs, and build projects.
 
-ACT IMMEDIATELY. For a user coding request (fix, add, implement, build, change, update): begin with a tool call (read_file, write_file, search_replace, bash with a real command, etc.) — not a planning paragraph. Do NOT explain or ask first when the next step is clear. Call a tool NOW. This applies to EVERY new user message that asks for code work.
+ACT IMMEDIATELY. For a user coding request (fix, add, implement, build, change, update): begin with a tool call (read_file, write_file, bash with a real command, etc.) — not a planning paragraph. Do NOT explain or ask first when the next step is clear. Call a tool NOW. This applies to EVERY new user message that asks for code work.
 
-EXCEPTION: if you genuinely do not know which tool to use, emit a SHORT (1-2 line) text response — NEVER a bash call containing only a comment like `# I need to use search_replace`. A comment-as-bash is worse than a sentence of text. When in doubt: write one sentence of text, then call the right tool on the next turn.
+EXCEPTION: if you genuinely do not know which tool to use, emit a SHORT (1-2 line) text response — NEVER a bash call containing only a comment. A comment-as-bash is worse than a sentence of text. When in doubt: write one sentence of text, then call the right tool on the next turn.
 
 When ANY bash command (including `python3 -c` inline scripts) returns IDENTICAL output 3 or more times in a row: STOP repeating it. Switch tools: use read_file to read file contents, grep to search for symbols, write_file to create missing files. Repeating the same bash command will never produce a different result.
 
 When running tests (pytest, unittest, cargo test, go test, npm test) and you see IDENTICAL failure output 3 or more times in a row: STOP re-running. Identical failures mean the bug is in your source code — the test will not pass on its own. (1) read the failure message and locate the specific file+line, (2) use grep or cat to inspect the failing code, (3) fix the root cause in the source file, (4) then run once to verify.
 
-Your tools: read_file, write_file, search_replace, mechanical_rename, grep, glob, bash, task, web_search, web_fetch, retrieve, math, count, memory, verify, logic, algebra, number_theory, set, linear_algebra, stats, units, chemistry, solve, prolog.
+Your tools: read_file, write_file, mechanical_rename, grep, glob, bash, lsp, web_search, web_fetch, retrieve, math, verify, count, logic, algebra, number_theory, set, linear_algebra, stats, units, chemistry, solve, prolog.
 
-For renaming an identifier across multiple files (e.g. "rename `units` to `quantity` everywhere", "introduce a Backend ABC and have both backends inherit"), prefer `mechanical_rename(old_name, new_name, scope, kind)` over a search_replace cascade — it applies the rename atomically across all .py files in scope, runs pytest, and rolls back if the suite goes red. `kind` is one of: `function`, `class`, `field` (field also rewrites dict-key string literals), or `auto`.
+For renaming an identifier across multiple files (e.g. "rename `units` to `quantity` everywhere", "introduce a Backend ABC and have both backends inherit"), prefer `mechanical_rename(old_name, new_name, scope, kind)` over manual edits — it applies the rename atomically across all .py files in scope, runs pytest, and rolls back if the suite goes red. `kind` is one of: `function`, `class`, `field` (field also rewrites dict-key string literals), or `auto`.
 
 CURIOSITY — default posture is "investigate, then assert":
 - If the user message names a thing you don't have context for (paper title, library, API, identifier, project-specific term), your FIRST tool call is `retrieve(query="<the term>")`. Not text. Not web_search. Retrieve.
@@ -18,10 +18,10 @@ CURIOSITY — default posture is "investigate, then assert":
 - When retrieved evidence contradicts what you were about to say, prefer the evidence and say so.
 - Don't ask the user to clarify before you've tried one investigation pass. Read the obvious files; retrieve the obvious terms.
 - NEVER say "X is already implemented" without first calling read_file or bash ls to confirm.
-- Writing "I created/wrote/implemented X" in text does NOT create any file. Only a write_file or search_replace tool call does.
+- Writing "I created/wrote/implemented X" in text does NOT create any file. Only a write_file tool call does.
 - NEVER announce "Task complete", "I have completed", or "Done" before running the verification command.
 - If ANY tool returns `<tool_error>` (glob failed, read_file failed, file not found), that step FAILED. Adjust and retry, do not declare success.
-- When asked to add MULTIPLE items, work through EACH one with a write_file or search_replace call.
+- When asked to add MULTIPLE items, work through EACH one with a write_file call.
 - NEVER write "✅ Verified" or any checkmark for a file or test you have not actually run/read in this session.
 
 WHEN TO USE retrieve (project's GraphRAG index):
@@ -38,15 +38,6 @@ WHEN TO USE WEB TOOLS (sparingly):
 - Found a URL to a relevant SO post or doc: `web_fetch`
 - DO NOT web-search for things you already know how to do. Write the code first.
 
-DELEGATION (only for genuinely large tasks):
-- 1-8 files → BUILD INLINE. Do not call task.
-- 9+ files with multiple subdirectories → DELEGATE to builder.
-- Editing an existing file or fixing a known bug → BUILD INLINE.
-- "Where does function X live?" → DELEGATE to explore.
-- If the user asks you to PLAN or EXPLAIN → respond with text. Do not delegate.
-
-When in doubt, build inline. A wasted delegation costs 60-90 seconds.
-
 Workflow for building from a PRD or spec:
 1. Read the spec file
 2. Create each file with write_file — start with __init__.py and __main__.py
@@ -58,15 +49,8 @@ Workflow for building from a PRD or spec:
 Workflow for fixing bugs:
 1. Grep for the function/class mentioned
 2. Read the source file
-3. Fix with search_replace
-4. Verify the fix
-
-search_replace rules:
-- Always read_file the target file IMMEDIATELY BEFORE the search_replace. Stale memory is the #1 cause of "Search text not found" failures.
-- The SEARCH block must be EXACT — same whitespace, indentation, quote style, variable names — as the file's current state.
-- If you edited the file earlier this session, read it AGAIN before the next search_replace; your earlier edits changed the content.
-- After a search_replace lands cleanly, do NOT search_replace the same file again without re-reading.
-- If search_replace fails with "Search text not found", call read_file BEFORE retrying — do NOT retry with the same SEARCH block.
+3. Fix with a new write_file of the corrected file
+4. Verify the fix with bash
 
 CORE PRINCIPLES:
 1. Don't assume. Don't hide confusion. Surface tradeoffs.

{drydock_cli-2.9.105 → drydock_cli-2.9.109}/pyproject.toml

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

{drydock_cli-2.9.105 → drydock_cli-2.9.109}/tests/test_loop_regressions_2026_06_06.py

@@ -121,17 +121,93 @@ class TestConsecutiveWriteDuplicatePreflight:
     is advisory-only by design (feedback_no_tool_errors_for_loop_...)
     and Gemma 4 ignored the advisory. The preflight prunes the
     duplicates from history so the model's next turn sees a clean
-    context. Pin the preflight marker so refactors surface here."""
+    context."""
 
     def test_preflight_marker_present_in_agent_loop(self):
         text = open(
             "/data3/drydock/drydock/core/agent_loop.py"
         ).read()
-        assert "PREFLIGHT-WRITE-DUP" in text, (
-            "consecutive-write preflight was removed from agent_loop.py"
+        # v2.9.108 generalized the marker from PREFLIGHT-WRITE-DUP to
+        # PREFLIGHT-DUP (covers any tool with 5+ identical-args calls).
+        assert "PREFLIGHT-DUP" in text, (
+            "duplicate-call preflight was removed from agent_loop.py"
         )
-        assert "5 and len(dup_indices)" in text or "dup_count >= 5" in text, (
-            "duplicate-write threshold changed; update test"
+        assert "dup_count >= 5" in text, (
+            "duplicate-call threshold changed; update test"
+        )
+
+    def test_preflight_prunes_history_to_most_recent_attempt(self):
+        """Behavioral: 7 identical writes + tool results -> 2 messages
+        remain after the preflight logic runs (most recent write + its
+        result). Replicates the sam-cell-seg pattern."""
+        import json as _json
+        from drydock.core.agent_loop import AgentLoop
+        from drydock.core.types import (
+            FunctionCall,
+            LLMMessage,
+            MessageList,
+            Role,
+            ToolCall,
+        )
+
+        msgs = MessageList()
+        identical_args = _json.dumps(
+            {"path": "/app/foo.smd", "content": "out0 = out0\nout1 = out1\n"}
+        )
+        for i in range(7):
+            msgs.append(LLMMessage(
+                role=Role.assistant,
+                content="",
+                tool_calls=[ToolCall(
+                    id=f"call_{i}",
+                    function=FunctionCall(
+                        name="write_file", arguments=identical_args
+                    ),
+                )],
+            ))
+            msgs.append(LLMMessage(
+                role=Role.tool,
+                content="advisory no-op",
+                tool_call_id=f"call_{i}",
+            ))
+
+        al = object.__new__(AgentLoop)
+        al.messages = msgs
+
+        # Reproduce the inline preflight logic exactly
+        cur_path = "/app/foo.smd"
+        cur_content = "out0 = out0\nout1 = out1\n"
+        dup_indices = []
+        for i, m in enumerate(al.messages):
+            if m.role != Role.assistant or not m.tool_calls:
+                continue
+            for tc in m.tool_calls:
+                if tc.function.name != "write_file":
+                    continue
+                try:
+                    a = _json.loads(tc.function.arguments or "{}")
+                except Exception:
+                    continue
+                ap = a.get("path") or a.get("file_path") or ""
+                ac = a.get("content", "")
+                if ap == cur_path and ac == cur_content:
+                    dup_indices.append(i)
+                    break
+        dup_count = len(dup_indices)
+        assert dup_count == 7
+
+        to_drop = set()
+        for idx in dup_indices[:-1]:
+            to_drop.add(idx)
+            if idx + 1 < len(al.messages):
+                next_m = al.messages[idx + 1]
+                if next_m.role == Role.tool:
+                    to_drop.add(idx + 1)
+        kept = [m for i, m in enumerate(al.messages) if i not in to_drop]
+        al.messages.reset(kept)
+        assert len(al.messages) == 2, (
+            f"expected 2 messages remaining (last write + result), "
+            f"got {len(al.messages)}"
         )
 
 
@@ -226,3 +302,133 @@ class TestUnionGrammarDefaultOff:
         gbnf = build_union_gbnf([("write_file", WriteFileArgs)])
         assert gbnf is not None
         assert "write_file" in gbnf or "root" in gbnf
+
+
+class TestGeneralizedDuplicatePreflight:
+    """v2.9.108: the preflight handles ANY tool with 5+ identical-args
+    calls, not just write_file. Verifies the v2.9.95 distribution-search
+    pattern (3 identical `solve` calls at end of trial) would be
+    pruned."""
+
+    def test_solve_loop_pattern_prunes(self):
+        import json as _json
+        from drydock.core.agent_loop import AgentLoop
+        from drydock.core.types import (
+            FunctionCall,
+            LLMMessage,
+            MessageList,
+            Role,
+            ToolCall,
+        )
+
+        msgs = MessageList()
+        # 6 identical solve calls — same args, same conclusion.
+        solve_args = _json.dumps({
+            "op": "solve",
+            "variables": "p1: Real, p2: Real",
+            "conclusion": "True",
+            "objective": "",
+        })
+        for i in range(6):
+            msgs.append(LLMMessage(
+                role=Role.assistant,
+                content="",
+                tool_calls=[ToolCall(
+                    id=f"solve_{i}",
+                    function=FunctionCall(name="solve", arguments=solve_args),
+                )],
+            ))
+            msgs.append(LLMMessage(
+                role=Role.tool,
+                content="sat",
+                tool_call_id=f"solve_{i}",
+            ))
+
+        al = object.__new__(AgentLoop)
+        al.messages = msgs
+
+        # Reproduce the inline generic preflight
+        cur_name = "solve"
+        cur_args_dict = _json.loads(solve_args)
+        cur_args_json = _json.dumps(cur_args_dict, sort_keys=True, default=str)
+        dup_indices = []
+        for i, m in enumerate(al.messages):
+            if m.role != Role.assistant or not m.tool_calls:
+                continue
+            for tc in m.tool_calls:
+                if tc.function.name != cur_name:
+                    continue
+                try:
+                    a = _json.loads(tc.function.arguments or "{}")
+                except Exception:
+                    continue
+                if _json.dumps(a, sort_keys=True, default=str) == cur_args_json:
+                    dup_indices.append(i)
+                    break
+
+        assert len(dup_indices) == 6
+        to_drop = set()
+        for idx in dup_indices[:-1]:
+            to_drop.add(idx)
+            if idx + 1 < len(al.messages):
+                if al.messages[idx + 1].role == Role.tool:
+                    to_drop.add(idx + 1)
+        kept = [m for i, m in enumerate(al.messages) if i not in to_drop]
+        al.messages.reset(kept)
+        # 5 older duplicates + their tool results = 10 dropped, 2 remain
+        assert len(al.messages) == 2
+
+    def test_different_args_NOT_pruned(self):
+        """read_file with different offsets — legitimate progress, NOT a dup."""
+        import json as _json
+        from drydock.core.agent_loop import AgentLoop
+        from drydock.core.types import (
+            FunctionCall,
+            LLMMessage,
+            MessageList,
+            Role,
+            ToolCall,
+        )
+
+        msgs = MessageList()
+        for i in range(8):
+            args = _json.dumps({"path": "/app/foo.py", "offset": i * 100})
+            msgs.append(LLMMessage(
+                role=Role.assistant,
+                content="",
+                tool_calls=[ToolCall(
+                    id=f"read_{i}",
+                    function=FunctionCall(name="read_file", arguments=args),
+                )],
+            ))
+            msgs.append(LLMMessage(
+                role=Role.tool,
+                content=f"contents at offset {i*100}",
+                tool_call_id=f"read_{i}",
+            ))
+
+        al = object.__new__(AgentLoop)
+        al.messages = msgs
+
+        # Now check what the preflight would do for "the 9th read_file
+        # call with offset=900". cur_args_json differs from all prior 8
+        # calls (each had a different offset).
+        cur_args_json = _json.dumps(
+            {"path": "/app/foo.py", "offset": 900}, sort_keys=True
+        )
+        dup_indices = []
+        for i, m in enumerate(al.messages):
+            if m.role != Role.assistant or not m.tool_calls:
+                continue
+            for tc in m.tool_calls:
+                if tc.function.name != "read_file":
+                    continue
+                try:
+                    a = _json.loads(tc.function.arguments or "{}")
+                except Exception:
+                    continue
+                if _json.dumps(a, sort_keys=True, default=str) == cur_args_json:
+                    dup_indices.append(i)
+                    break
+        # No duplicates of {offset:900} in history — preflight stays inert
+        assert dup_indices == []

{drydock_cli-2.9.105 → drydock_cli-2.9.109}/uv.lock

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