drydock-cli 2.7.21__tar.gz → 2.7.23__tar.gz

drydock_cli-2.7.23/.auto_release.lock

@@ -0,0 +1 @@
+542815

{drydock_cli-2.7.21 → drydock_cli-2.7.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.7.21
+Version: 2.7.23
 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.21 → drydock_cli-2.7.23}/drydock/admiral/detectors.py

@@ -85,12 +85,20 @@ def detect_struggle(messages: Sequence[LLMMessage], threshold: int = 20) -> Find
     # 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."
-        )
+        if last_write_tool is None:
+            directive = (
+                f"Admiral: you have made {calls_since_write} tool calls without "
+                f"writing a single file. You have enough context. STOP exploring "
+                f"and start writing code NOW. Call `write_file` to create your "
+                f"first file immediately."
+            )
+        else:
+            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 "

{drydock_cli-2.7.21 → drydock_cli-2.7.23}/drydock/core/agent_loop.py

@@ -1032,7 +1032,7 @@ class AgentLoop:
         parsed = self.format_handler.parse_message(last_message)
         resolved = self.format_handler.resolve_tool_calls(parsed, self.tool_manager)
 
-        if not resolved.tool_calls and not resolved.failed_calls:
+        if not resolved.tool_calls and not resolved.failed_calls and not resolved.suppressed_failures:
             return
 
         async for event in self._handle_tool_calls(resolved):
@@ -1148,6 +1148,10 @@ class AgentLoop:
         threshold = 5 if is_readonly else 8
         if count < threshold:
             return None
+        # Increment so the count escalates on every repeated fire, giving the
+        # model a growing signal that nothing has changed.  Preserve last_result
+        # so the message always shows the real bash/tool output, not a prior NOTE.
+        self._tool_call_history[sig] = (count + 1, last_result)
         return (
             f"NOTE: this exact call to `{tool_name}` has been made "
             f"{count} times this session with identical arguments. "
@@ -1777,6 +1781,11 @@ class AgentLoop:
                 for tc in msg.tool_calls:
                     if not tc.function or not tc.function.arguments:
                         continue
+                    # search_replace args contain SEARCH/REPLACE blocks the model
+                    # NEEDS to see in history (to know what edits it already applied).
+                    # Only write_file carries full file content worth truncating.
+                    if tc.function.name == "search_replace":
+                        continue
                     args = tc.function.arguments
                     if len(args) <= SOFT_CAP_BYTES:
                         continue

{drydock_cli-2.7.21 → drydock_cli-2.7.23}/drydock/core/llm/format.py

@@ -447,14 +447,25 @@ class APIToolFormatHandler:
                         dir_listing = "\n".join(f"  {f}" for f in py_files)
                     except Exception:
                         dir_listing = "  (could not list files)"
+                    tool_name_hint = parsed_call.tool_name
+                    if tool_name_hint == "search_replace":
+                        recovery_hint = (
+                            f"Use read_file on '{path_hint}' to see its current content, "
+                            f"then call search_replace with fresh <<<<<<< SEARCH / ======= / "
+                            f">>>>>>> REPLACE markers copied from the actual file text."
+                        )
+                    else:
+                        recovery_hint = (
+                            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."
+                        )
                     escalation_suffix = (
-                        f"\n\n[REPEATED FAILURE #{hit_count}: your write_file call "
+                        f"\n\n[REPEATED FAILURE #{hit_count}: your {tool_name_hint} call "
                         f"keeps using a stale truncated template for '{path_hint}'. "
-                        f"You MUST type fresh content — do NOT copy from history. "
+                        f"You MUST NOT copy args 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.]"
+                        f"{recovery_hint}]"
                     )
                 else:
                     escalation_suffix = ""

{drydock_cli-2.7.21 → drydock_cli-2.7.23}/pyproject.toml

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

drydock_cli-2.7.23/tests/core/test_circuit_breaker_count_escalation.py

@@ -0,0 +1,93 @@
+"""Regression test: circuit breaker count escalates on repeated fires.
+
+Bug: _circuit_breaker_check returned the NOTE but never incremented the count
+in _tool_call_history when it fired.  Every retry got the same "8 times" message,
+so the escalation signal was flat and the model never broke out.
+
+Fix: _circuit_breaker_check now increments the count on each fire, giving the
+model an increasing signal that nothing has changed.
+"""
+import unittest
+from unittest.mock import MagicMock
+
+
+def _make_loop():
+    from drydock.core.agent_loop import AgentLoop
+    loop = AgentLoop.__new__(AgentLoop)
+    loop._tool_call_history = {}
+    loop._get_attempted_summary = lambda: ""
+    return loop
+
+
+def _make_tc(name, args):
+    tc = MagicMock()
+    tc.tool_name = name
+    tc.args_dict = args
+    tc.call_id = "test-id"
+    return tc
+
+
+def _record(loop, tc, result="output"):
+    from drydock.core.agent_loop import AgentLoop
+    AgentLoop._circuit_breaker_record(loop, tc, result)
+
+
+class TestCircuitBreakerCountEscalation(unittest.TestCase):
+    def test_count_escalates_on_repeated_fires(self):
+        """After the threshold, each fire increments the count so the message escalates."""
+        loop = _make_loop()
+        tc = _make_tc("bash", {"command": "python3 -m tool_agent run foo"})
+
+        # Reach threshold (8 recorded calls)
+        for _ in range(8):
+            _record(loop, tc, "some output")
+
+        # First fire: should mention 8
+        msg1 = loop._circuit_breaker_check(tc)
+        self.assertIsNotNone(msg1)
+        self.assertIn("8 times", msg1)
+
+        # Second fire (without any external record call): should mention 9
+        msg2 = loop._circuit_breaker_check(tc)
+        self.assertIsNotNone(msg2)
+        self.assertIn("9 times", msg2)
+
+        # Third fire: should mention 10
+        msg3 = loop._circuit_breaker_check(tc)
+        self.assertIsNotNone(msg3)
+        self.assertIn("10 times", msg3)
+
+    def test_last_result_preserved_across_fires(self):
+        """last_result shown in NOTE stays as the real tool output, not a prior NOTE."""
+        loop = _make_loop()
+        tc = _make_tc("bash", {"command": "echo hello"})
+
+        for _ in range(8):
+            _record(loop, tc, "hello\n")
+
+        msg1 = loop._circuit_breaker_check(tc)
+        self.assertIn("hello", msg1)
+
+        # After a second fire, last_result should still be the original output
+        msg2 = loop._circuit_breaker_check(tc)
+        self.assertIn("hello", msg2)
+        # Not the prior NOTE text
+        self.assertNotIn("NOTE: this exact call", msg2.split("Last result:")[1])
+
+    def test_count_below_threshold_unaffected(self):
+        """Calls below threshold still return None and don't mutate state unexpectedly."""
+        loop = _make_loop()
+        tc = _make_tc("bash", {"command": "ls"})
+
+        for i in range(7):
+            result = loop._circuit_breaker_check(tc)
+            self.assertIsNone(result, f"Should not fire on call {i+1} (count={i})")
+            _record(loop, tc)
+
+        # 8th call is still below threshold (count=7 < 8)
+        result = loop._circuit_breaker_check(tc)
+        self.assertIsNone(result)
+
+
+if __name__ == "__main__":
+    unittest.main()

{drydock_cli-2.7.21 → drydock_cli-2.7.23}/tests/test_admiral_struggle_dedup.py

@@ -66,3 +66,34 @@ def test_struggle_gentle_directive_below_30() -> None:
 def test_struggle_no_fire_below_threshold() -> None:
     msgs = _make_msgs("write_file", 5)
     assert detect_struggle(msgs) is None
+
+
+def _make_msgs_no_write(non_write_count: int) -> list[LLMMessage]:
+    """Messages where the model never called any write tool."""
+    msgs: list[LLMMessage] = [LLMMessage(role=Role.user, content="build it")]
+    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_none_escalated_says_start_writing() -> None:
+    """When model never wrote a file and hits 30+ calls, directive must not
+    mention search_replace (model never used it) and must urge writing."""
+    msgs = _make_msgs_no_write(30)
+    f = detect_struggle(msgs)
+    assert f is not None
+    assert f.code == "struggle:none"
+    assert "search_replace" not in f.directive
+    assert "write_file" in f.directive
+    assert "exploring" in f.directive or "STOP" in f.directive
+
+
+def test_struggle_with_prior_write_escalated_mentions_search_replace() -> None:
+    """When model previously wrote and is now stuck retrying, the search_replace
+    message is appropriate."""
+    msgs = _make_msgs("search_replace", 30)
+    f = detect_struggle(msgs)
+    assert f is not None
+    assert "search_replace" in f.directive
+    assert "overwrite" in f.directive

{drydock_cli-2.7.21 → drydock_cli-2.7.23}/tests/test_hallucinated_tool_suppression.py

@@ -85,3 +85,37 @@ def test_unknown_non_hallucinated_tool_goes_to_failed_calls():
     resolved = handler.resolve_tool_calls(parsed, tm)
     assert any(fc.tool_name == "nonexistent_random_tool" for fc in resolved.failed_calls)
     assert not resolved.suppressed_failures
+
+
+def test_suppressed_failures_not_bypassed_by_early_return():
+    """Regression for agent_loop early-return bug: when only suppressed_failures
+    exist (no real tool_calls, no failed_calls), the condition
+    `not tool_calls and not failed_calls` was True and _handle_tool_calls was
+    skipped, so _silence_suppressed_failures was never called. The tool result
+    message for the hallucinated tool was never added, leaving the conversation
+    malformed (assistant tool_call with no paired tool result).
+
+    Fix: early-return also checks `not suppressed_failures`.
+    This test verifies that a ResolvedMessage with only suppressed_failures
+    is NOT considered empty by the fixed condition.
+    """
+    handler = _make_handler()
+    tm = _make_tool_manager(["read_file"])
+    parsed = _parsed("ralph_repo_index")
+    resolved = handler.resolve_tool_calls(parsed, tm)
+
+    # Preconditions: only suppressed_failures, nothing else
+    assert not resolved.tool_calls
+    assert not resolved.failed_calls
+    assert resolved.suppressed_failures
+
+    # The fixed early-return condition must NOT consider this "no work to do"
+    should_skip_early = (
+        not resolved.tool_calls
+        and not resolved.failed_calls
+        and not resolved.suppressed_failures  # fixed: was missing this
+    )
+    assert not should_skip_early, (
+        "Bug regression: suppressed_failures were ignored by early-return, "
+        "leaving assistant tool_call with no paired tool result in history."
+    )

drydock_cli-2.7.23/tests/test_search_replace_args_not_truncated.py

@@ -0,0 +1,181 @@
+"""Regression test: search_replace call args must NOT be truncated.
+
+Repro: _truncate_old_tool_results truncated ALL large tool-call arguments,
+including search_replace SEARCH/REPLACE blocks (~400-800 bytes). The model
+then saw {_truncated: true, file_path: "..."} in its own history and copied
+those truncated args as new call arguments. format.py detected this and
+returned a FailedToolCall, but the model retried with the same truncated
+args again and again, creating a retry_after_error:search_replace loop.
+
+Fix (2026-04-29): skip the arg-truncation loop for search_replace tool
+calls. Only write_file carries full file content worth truncating.
+"""
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from drydock.core.types import (
+    FunctionCall,
+    LLMMessage,
+    Role,
+    ToolCall,
+)
+from tests.conftest import build_test_agent_loop
+
+
+def _make_tc(name: str, arguments: str, idx: int = 0) -> ToolCall:
+    return ToolCall(
+        id=f"tc_{idx}",
+        index=idx,
+        function=FunctionCall(name=name, arguments=arguments),
+    )
+
+
+def _build_history_with_search_replace(num_old: int) -> list[LLMMessage]:
+    """Build a conversation with `num_old` old search_replace messages
+    plus enough newer messages to exceed KEEP_RECENT."""
+    msgs: list[LLMMessage] = [
+        LLMMessage(role=Role.system, content="be helpful"),
+        LLMMessage(role=Role.user, content="please help"),
+    ]
+    # search_replace calls with realistic 600+ byte args (exceeds SOFT_CAP=500)
+    search_block = "    def run_tool(self, tool_name: str, args: dict) -> str:\n"
+    search_block += "        # This is the old implementation that needs to be replaced\n"
+    search_block += "        return ''\n"
+    replace_block = "    def run_tool(self, tool_name: str, args: dict) -> str:\n"
+    replace_block += "        plugin = self._load_plugin(tool_name)\n"
+    replace_block += "        if plugin is None:\n"
+    replace_block += "            raise ValueError(f'Unknown tool: {tool_name}')\n"
+    replace_block += "        return plugin.execute(args)\n"
+    sr_args = json.dumps({
+        "file_path": "/data3/drydock_test_projects/403_tool_agent/tool_agent/cli.py",
+        "content": (
+            f"<<<<<<< SEARCH\n{search_block}=======\n{replace_block}>>>>>>> REPLACE"
+        ),
+    })
+    assert len(sr_args) > 500, f"Test args must exceed SOFT_CAP_BYTES=500 to be meaningful, got {len(sr_args)}"
+
+    for i in range(num_old):
+        msgs.append(
+            LLMMessage(
+                role=Role.assistant,
+                content="",
+                tool_calls=[_make_tc("search_replace", sr_args, i)],
+            )
+        )
+        msgs.append(
+            LLMMessage(
+                role=Role.tool,
+                tool_call_id=f"tc_{i}",
+                name="search_replace",
+                content="Applied edit.",
+            )
+        )
+
+    # Add newer messages to exceed KEEP_RECENT (4) so truncation would trigger
+    # for write_file but should be skipped for search_replace.
+    for i in range(6):
+        msgs.append(
+            LLMMessage(
+                role=Role.assistant,
+                content="",
+                tool_calls=[_make_tc("read_file", '{"path":"/x"}', 100 + i)],
+            )
+        )
+        msgs.append(
+            LLMMessage(
+                role=Role.tool,
+                tool_call_id=f"tc_{100+i}",
+                name="read_file",
+                content="ok",
+            )
+        )
+    return msgs
+
+
+class TestSearchReplaceArgsNotTruncated:
+    def test_search_replace_args_preserved_after_truncation(self):
+        """search_replace call args must not be replaced with {_truncated: true} stub."""
+        loop = build_test_agent_loop()
+        loop.messages.reset(_build_history_with_search_replace(num_old=10))
+
+        loop._truncate_old_tool_results()
+
+        for m in loop.messages:
+            if m.role != Role.assistant or not m.tool_calls:
+                continue
+            for tc in m.tool_calls:
+                if tc.function.name != "search_replace":
+                    continue
+                args = tc.function.arguments or ""
+                parsed = json.loads(args)
+                assert not parsed.get("_truncated"), (
+                    f"search_replace args were truncated — model will copy the stub "
+                    f"and loop: {args[:120]}"
+                )
+                assert "content" in parsed, (
+                    "search_replace args lost the 'content' field after truncation"
+                )
+
+    def test_write_file_still_truncated(self):
+        """write_file args should still be truncated (they carry full file content)."""
+        msgs: list[LLMMessage] = [
+            LLMMessage(role=Role.system, content="be helpful"),
+            LLMMessage(role=Role.user, content="please help"),
+        ]
+        big_args = json.dumps({
+            "file_path": "/data3/test/foo.py",
+            "content": "x" * 5000,
+        })
+        for i in range(10):
+            msgs.append(
+                LLMMessage(
+                    role=Role.assistant,
+                    content="",
+                    tool_calls=[_make_tc("write_file", big_args, i)],
+                )
+            )
+            msgs.append(
+                LLMMessage(
+                    role=Role.tool,
+                    tool_call_id=f"tc_{i}",
+                    name="write_file",
+                    content=f"Wrote {i}",
+                )
+            )
+        for i in range(6):
+            msgs.append(
+                LLMMessage(
+                    role=Role.assistant,
+                    content="",
+                    tool_calls=[_make_tc("read_file", '{"path":"/x"}', 100 + i)],
+                )
+            )
+            msgs.append(
+                LLMMessage(
+                    role=Role.tool,
+                    tool_call_id=f"tc_{100+i}",
+                    name="read_file",
+                    content="ok",
+                )
+            )
+
+        loop = build_test_agent_loop()
+        loop.messages.reset(msgs)
+        loop._truncate_old_tool_results()
+
+        truncated_count = 0
+        for m in loop.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
+                args = tc.function.arguments or ""
+                parsed = json.loads(args)
+                if parsed.get("_truncated"):
+                    truncated_count += 1
+
+        assert truncated_count > 0, "write_file args should still be truncated"

drydock_cli-2.7.23/tests/test_truncated_search_replace_escalation.py

@@ -0,0 +1,76 @@
+"""Regression test: truncated search_replace escalation uses correct tool name.
+
+When Gemma 4 calls search_replace with _truncated args, the escalation message
+must say "search_replace call" and give SEARCH/REPLACE recovery guidance —
+not "write_file call" and "call write_file with typed content".
+
+The wrong tool name in the escalation confused the model into switching to
+write_file (full overwrite) instead of reading the file and forming fresh
+SEARCH/REPLACE blocks. Observed via admiral retry_after_error:search_replace
+loops in stress run 2026-04-29.
+"""
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+from drydock.core.llm.format import APIToolFormatHandler, ParsedMessage, ParsedToolCall
+from drydock.core.tools.builtins.search_replace import SearchReplace
+
+
+def _make_tm():
+    tm = MagicMock()
+    tm.available_tools = {"search_replace": SearchReplace}
+    return tm
+
+
+def _truncated_sr_call(path: str, call_id: str = "tc1") -> ParsedMessage:
+    return ParsedMessage(
+        tool_calls=[
+            ParsedToolCall(
+                tool_name="search_replace",
+                call_id=call_id,
+                raw_args={
+                    "_truncated": True,
+                    "_original_bytes": 1230,
+                    "file_path": path,
+                },
+            )
+        ]
+    )
+
+
+class TestTruncatedSearchReplaceEscalation:
+    def test_first_hit_mentions_search_replace(self, tmp_path):
+        """First truncated-arg failure for search_replace mentions the right tool."""
+        target = tmp_path / "cli.py"
+        target.write_text("def run(): pass\n")
+        handler = APIToolFormatHandler()
+        result = handler.resolve_tool_calls(_truncated_sr_call(str(target)), _make_tm())
+        err = result.failed_calls[0].error
+        assert "truncated" in err.lower()
+        assert "REPEATED FAILURE" not in err
+
+    def test_second_hit_escalates_with_correct_tool_name(self, tmp_path):
+        """Escalation message says 'search_replace call', not 'write_file call'."""
+        target = tmp_path / "utils.py"
+        target.write_text("x = 1\n")
+        handler = APIToolFormatHandler()
+        handler.resolve_tool_calls(_truncated_sr_call(str(target), "tc1"), _make_tm())
+        result = handler.resolve_tool_calls(_truncated_sr_call(str(target), "tc2"), _make_tm())
+        err = result.failed_calls[0].error
+        assert "REPEATED FAILURE #2" in err
+        assert "search_replace call" in err
+        assert "write_file call" not in err
+
+    def test_second_hit_escalation_gives_search_replace_recovery(self, tmp_path):
+        """Escalation for search_replace suggests SEARCH/REPLACE markers, not write_file."""
+        target = tmp_path / "agent.py"
+        target.write_text("def run(): pass\n")
+        handler = APIToolFormatHandler()
+        handler.resolve_tool_calls(_truncated_sr_call(str(target), "tc1"), _make_tm())
+        result = handler.resolve_tool_calls(_truncated_sr_call(str(target), "tc2"), _make_tm())
+        err = result.failed_calls[0].error
+        assert "SEARCH" in err
+        assert "REPLACE" in err
+        # Must NOT redirect to write_file as the primary recovery path
+        assert "then call write_file" not in err