drydock-cli 2.9.87__tar.gz → 2.9.89__tar.gz

{drydock_cli-2.9.87 → drydock_cli-2.9.89}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.9.87
+Version: 2.9.89
 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.87 → drydock_cli-2.9.89}/drydock/core/llm/grammar/policy.py

@@ -89,8 +89,17 @@ def select_grammar(
         )
         return None, None
 
+    # Tighten the schema: Pydantic `Field(default="")` markers in
+    # drydock args models leak as non-required JSON-Schema fields, and
+    # the grammar then lets the model emit empty paths / no-content
+    # writes. Reuse the union-grammar tightener. See policy_union for
+    # the heuristic.
+    from drydock.core.llm.grammar.policy_union import _tighten_args_schema
     try:
-        gbnf = pydantic_to_gbnf(args_model)
+        raw_schema = args_model.model_json_schema()
+        tight_schema = _tighten_args_schema(raw_schema)
+        from drydock.core.llm.grammar import json_schema_to_gbnf
+        gbnf = json_schema_to_gbnf(tight_schema)
     except Exception as e:
         logger.warning(
             "[GRAMMAR-POLICY] failed to compile %s args to GBNF: %s",

{drydock_cli-2.9.87 → drydock_cli-2.9.89}/drydock/core/llm/grammar/policy_union.py

@@ -44,6 +44,67 @@ _COMMON_RULES = ("space", "string", "char", "boolean", "null", "number",
                  "integer", "value")
 
 
+def _tighten_args_schema(schema: dict[str, Any]) -> dict[str, Any]:
+    """Force fields with vacuous defaults to be required in the grammar.
+
+    Pydantic args models in drydock use `Field(default="")` so the
+    AUTO-INFER recovery path can rewrite partial calls. But that makes
+    the JSON Schema mark those fields as optional, and the grammar then
+    accepts `{}` as valid args — the model under grammar emits empty
+    paths and garbage content because the schema permits it.
+    Concretely: WriteFileArgs.path defaults to "" and the model under
+    grammar emitted 18 writes with `path=None` and identical 428-char
+    `out0 = out0\\nout1 = out1\\n...` gibberish (2026-06-06 v2.9.87 batch,
+    circuit-fibsqrt trial).
+
+    Heuristic: a field with default value `""`, `[]`, `{}`, or `None`
+    (when the type isn't nullable) is "vacuous" — the default never
+    represents a real intent, it's a placeholder for the recovery
+    machinery. Strip the default from such fields and add them to
+    `required`. Boolean / numeric / non-empty-string defaults are
+    legitimate optionals and left alone.
+
+    Returns a NEW dict; does not mutate the input.
+    """
+    if not isinstance(schema, dict):
+        return schema
+    out = dict(schema)
+    props = dict(out.get("properties") or {})
+    if not props:
+        return out
+    required = list(out.get("required") or [])
+    for name, spec in list(props.items()):
+        if not isinstance(spec, dict):
+            continue
+        if "default" not in spec:
+            continue
+        default = spec["default"]
+        is_vacuous = False
+        if default == "" or default == [] or default == {}:
+            is_vacuous = True
+        elif default is None:
+            # `default=None` is fine when the type is nullable, e.g.
+            # ReadFileArgs.limit (type: int|null). It's a problem only
+            # for fields whose schema type doesn't allow null — those
+            # are buggy-optionals. Detect via anyOf branches.
+            any_of = spec.get("anyOf") or []
+            type_allows_null = any(
+                isinstance(b, dict) and b.get("type") == "null"
+                for b in any_of
+            ) or spec.get("type") == "null"
+            if not type_allows_null:
+                is_vacuous = True
+        if is_vacuous:
+            new_spec = {k: v for k, v in spec.items() if k != "default"}
+            props[name] = new_spec
+            if name not in required:
+                required.append(name)
+    out["properties"] = props
+    if required:
+        out["required"] = required
+    return out
+
+
 def build_union_gbnf(
     tool_specs: list[tuple[str, type]],
 ) -> str | None:
@@ -68,6 +129,7 @@ def build_union_gbnf(
         except Exception as e:
             logger.debug("[UNION] %s schema err: %s — skipping", tool_name, e)
             continue
+        args_schema = _tighten_args_schema(args_schema)
         one_of_branches.append({
             "type": "object",
             "properties": {

{drydock_cli-2.9.87 → drydock_cli-2.9.89}/drydock/core/tools/builtins/bash.py

@@ -1305,7 +1305,7 @@ class Bash(
             if not _is_write_cmd:
                 _run_cnt = run_count_state.get(args.command, 0) + 1
                 run_count_state[args.command] = _run_cnt
-                if _run_cnt >= 5:
+                if _run_cnt >= 3:
                     cmd_preview = args.command[:80]
                     # Truncate the previous stdout heavily so the
                     # loop-breaker preamble isn't overshadowed by full
@@ -1346,7 +1346,7 @@ class Bash(
             if returncode != 0:
                 err_count = err_state.get(args.command, 0) + 1
                 err_state[args.command] = err_count
-                if err_count >= 5:
+                if err_count >= 3:
                     cmd_preview = args.command[:80]
                     notice = (
                         f"[NOTICE: `{cmd_preview}` has failed with a non-zero "

{drydock_cli-2.9.87 → drydock_cli-2.9.89}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "2.9.87"
+version = "2.9.89"
 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.87 → drydock_cli-2.9.89}/tests/core/test_config_resolution.py

@@ -102,7 +102,9 @@ class TestAutoCompactThresholdFallback:
         assert cfg.get_active_model().auto_compact_threshold == 99_000
 
     def test_default_global_threshold_used_when_nothing_set(self) -> None:
-        model = ModelConfig(name="m", provider="p", alias="m")
+        # context_window must exceed the global default (200K) or the ceiling
+        # clamp (context_window - 4096) fires and the assertion fails.
+        model = ModelConfig(name="m", provider="p", alias="m", context_window=500_000)
         cfg = build_test_drydock_config(models=[model], active_model="m")
         assert cfg.get_active_model().auto_compact_threshold == 200_000
 

{drydock_cli-2.9.87 → drydock_cli-2.9.89}/tests/test_grammar.py

@@ -22,7 +22,11 @@ from drydock.core.llm.grammar.policy import (
     apply_grammar,
     select_grammar,
 )
-from drydock.core.llm.grammar.policy_union import build_union_gbnf, select_union_grammar
+from drydock.core.llm.grammar.policy_union import (
+    _tighten_args_schema,
+    build_union_gbnf,
+    select_union_grammar,
+)
 
 
 # ---------------------------------------------------------------------------
@@ -321,3 +325,86 @@ def test_select_union_grammar_empty_tools_returns_none(monkeypatch):
         tool_manager=mgr,
     )
     assert gbnf is None
+
+
+# ---------------------------------------------------------------------------
+# Regression: vacuous-default fields must become grammar-required.
+# v2.9.87 batch had 18 write_file calls with path=None and identical
+# 428-char `out0 = out0\nout1 = out1\n...` garbage content because the
+# pydantic schema (path: str = Field(default="")) marked path as
+# non-required, the grammar accepted the empty default, and the model
+# committed to whatever fit. The tightener strips those defaults.
+# ---------------------------------------------------------------------------
+
+def test_tighten_args_schema_forces_empty_string_defaults_required():
+    schema = {
+        "properties": {
+            "path": {"type": "string", "default": ""},
+            "content": {"type": "string", "default": ""},
+            "overwrite": {"type": "boolean", "default": True},
+        },
+    }
+    out = _tighten_args_schema(schema)
+    assert set(out["required"]) == {"path", "content"}
+    assert "default" not in out["properties"]["path"]
+    assert "default" not in out["properties"]["content"]
+    # legit boolean default left alone
+    assert out["properties"]["overwrite"]["default"] is True
+
+
+def test_tighten_args_schema_preserves_nullable_optionals():
+    # ReadFileArgs.limit pattern: Optional[int] = None → type allows null,
+    # default=null is a legit "no limit" — must NOT be forced required.
+    schema = {
+        "properties": {
+            "path": {"type": "string"},
+            "limit": {
+                "anyOf": [{"type": "integer"}, {"type": "null"}],
+                "default": None,
+            },
+        },
+        "required": ["path"],
+    }
+    out = _tighten_args_schema(schema)
+    assert out["required"] == ["path"]
+    assert out["properties"]["limit"]["default"] is None
+
+
+def test_tighten_args_schema_real_write_file_args():
+    """End-to-end with the actual production WriteFileArgs."""
+    from drydock.core.tools.builtins.write_file import WriteFileArgs
+    raw = WriteFileArgs.model_json_schema()
+    # baseline: pydantic leaves it open
+    assert "required" not in raw or "path" not in raw.get("required", [])
+    tight = _tighten_args_schema(raw)
+    assert "path" in tight["required"]
+    assert "content" in tight["required"]
+    # overwrite stays optional
+    assert "overwrite" not in tight["required"]
+
+
+def test_union_grammar_requires_write_file_path_after_tightener():
+    """The grammar string itself must include the required-fields markers
+    for write_file's path. We assert by checking that the GBNF doesn't
+    contain a permissive write_file branch that lets path be omitted."""
+    from drydock.core.tools.builtins.write_file import WriteFileArgs
+    gbnf = build_union_gbnf([("write_file", WriteFileArgs)])
+    assert gbnf is not None
+    # Tool name + path appear as GBNF string constants (\"-escaped).
+    assert '\\"write_file\\"' in gbnf
+    assert '\\"path\\"' in gbnf
+    assert '\\"content\\"' in gbnf
+    # The smoking gun for the bug would be an args body rule that allows
+    # `{}` (no required keys). After the tightener, the args body opens
+    # with `path-kv "," space content-kv` — path and content are
+    # unconditional, overwrite is wrapped in `( ... )?`. Verify the args
+    # rule doesn't degenerate to `"{" space "}"`.
+    args_rule_line = next(
+        (ln for ln in gbnf.splitlines() if "-arguments ::=" in ln),
+        "",
+    )
+    assert args_rule_line, "expected an arguments rule in GBNF"
+    assert "path-kv" in args_rule_line  # path is in the args body
+    assert "content-kv" in args_rule_line  # content is in the args body
+    # overwrite (optional) should appear wrapped in `( ... )?`
+    assert "overwrite-kv )" in args_rule_line and "?" in args_rule_line

{drydock_cli-2.9.87 → drydock_cli-2.9.89}/uv.lock

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

drydock_cli-2.9.87/tests/core/test_circuit_breaker_count_escalation.py

@@ -1,94 +0,0 @@
-"""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)
-        assert msg2 is not None, "circuit breaker should fire on 10th call"
-        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.9.87/tests/core/test_circuit_breaker_readonly_threshold.py

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