drydock-cli 2.9.57__tar.gz → 2.9.59__tar.gz

{drydock_cli-2.9.57 → drydock_cli-2.9.59}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.9.57
+Version: 2.9.59
 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.57 → drydock_cli-2.9.59}/drydock/admiral/opus_escalator.py

@@ -39,7 +39,7 @@ the user, say so explicitly.
 
 Detector: {code}
 Admiral's canned fallback: "{fallback}"
-
+{loop_constraint}
 Recent conversation:
 <conversation>
 {context}
@@ -110,10 +110,20 @@ async def escalate(
     messages: Sequence[LLMMessage],
 ) -> str | None:
     """Ask Opus for a directive. Returns directive text or None."""
+    loop_constraint = ""
+    if finding.code.startswith("loop:bash::"):
+        cmd_snippet = finding.code[len("loop:bash::"):][:120]
+        loop_constraint = (
+            f"\nCRITICAL CONSTRAINT: The repeated command is `bash` with "
+            f"args `{cmd_snippet}`. Your directive MUST NOT suggest running "
+            f"this same command again — the model already has its output. "
+            f"Direct the agent to read/edit source code instead.\n"
+        )
     prompt = _OPUS_PROMPT.format(
         rubric=_DIRECTIVES_RUBRIC,
         code=finding.code,
         fallback=finding.directive[:200],
+        loop_constraint=loop_constraint,
         context=_render_turns(messages, n_turns=12),
     )
     out = await _try_anthropic_sdk(prompt)

{drydock_cli-2.9.57 → drydock_cli-2.9.59}/drydock/core/agent_loop.py

@@ -1680,6 +1680,70 @@ class AgentLoop:
                         expected_paths = list(dict.fromkeys(pat.findall(task_text)))[:10]
                     missing_expected = [p for p in expected_paths if p not in written_paths]
                     has_expected_misses = bool(expected_paths and missing_expected)
+
+                    # Fix E (2026-06-04): parse the task instruction for
+                    # explicit verify commands and check if the model has
+                    # ever run them. Targets the partial-pytest-credit
+                    # cluster — fix-code-vulnerability scored 5/6 pytest
+                    # but never ran the explicit `pytest -rA` the task
+                    # named. Same shape across 14 trials in v2.9.55 batch.
+                    expected_verifies: list[str] = []
+                    if len(self.messages) >= 2:
+                        task_text = (self.messages[1].content or "")
+                        import re as _re2
+                        # Patterns the model should run before exit:
+                        # - "you can run: `pytest -rA`"
+                        # - "verify by running `bash test.sh`"
+                        # - "to test, run `python test.py`"
+                        # - bare `pytest` mentions in instructions
+                        # Capture the command text (inside backticks first).
+                        cmd_patterns = [
+                            r"(?:you can run|verify by running|to test,?\s*run|"
+                            r"to verify,?\s*run|run the tests? with|tests? are run with|"
+                            r"verifier runs?|you may run|run\s+the\s+command|"
+                            r"to evaluate|evaluation command):\s*`([^`]+)`",
+                            r"verify by:?\s*`([^`]+)`",
+                            # bare backtick commands containing pytest/bash/make
+                            r"`(pytest\s[^`]*|bash\s+[^`]*\.sh[^`]*|make\s+test[^`]*|"
+                            r"npm\s+test[^`]*|cargo\s+test[^`]*|go\s+test[^`]*)`",
+                        ]
+                        for p in cmd_patterns:
+                            for m in _re2.finditer(p, task_text, _re2.IGNORECASE):
+                                cmd = m.group(1).strip()
+                                if cmd and cmd not in expected_verifies:
+                                    expected_verifies.append(cmd)
+                                    if len(expected_verifies) >= 5:
+                                        break
+                            if len(expected_verifies) >= 5:
+                                break
+                    # Did the model run any matching command via bash?
+                    ran_verify_cmds: list[str] = []
+                    if expected_verifies:
+                        bash_cmds: list[str] = []
+                        for msg in self.messages:
+                            for tc in (msg.tool_calls or []):
+                                fn_obj = tc.function
+                                if not fn_obj or fn_obj.name != "bash":
+                                    continue
+                                try:
+                                    import json as _json2
+                                    a = _json2.loads(fn_obj.arguments or "{}")
+                                    c = a.get("command") or ""
+                                    if c:
+                                        bash_cmds.append(c)
+                                except Exception:
+                                    pass
+                        # Match: any token of the expected command appears in
+                        # any of the model's bash commands. Lenient match
+                        # (model might add extra flags or paths).
+                        for ev in expected_verifies:
+                            first_token = ev.split()[0] if ev.split() else ev
+                            if any(first_token in bc for bc in bash_cmds):
+                                ran_verify_cmds.append(ev)
+                    missing_verify_cmds = [
+                        ev for ev in expected_verifies if ev not in ran_verify_cmds
+                    ]
+                    has_missing_verify = bool(missing_verify_cmds)
                     # Cap raised 5 → 10 nudges per session. Removed tool_turns
                     # gate entirely — the 2026-06-03 v2948 batch showed that
                     # most "engaged but failed" trials (bucket D, 26/50 fails)
@@ -1748,6 +1812,26 @@ class AgentLoop:
                                 f"no file, and partial-credit verifiers reward "
                                 f"format correctness even when content is off."
                             )
+                        elif has_missing_verify:
+                            # Fix E (2026-06-04): task explicitly names a
+                            # verify command (e.g. "you can run: `pytest -rA`")
+                            # and the model never executed it. 14 of 37 fails
+                            # in v2.9.55 had partial pytest credit (one named
+                            # 5/6, another 4/5) — they were ONE iteration away
+                            # from passing but never ran the verifier to see.
+                            note = (
+                                f"⚠ PREMATURE EXIT BLOCK #{nudges + 1}/10. "
+                                f"The task explicitly names this verify "
+                                f"command: `{missing_verify_cmds[0]}`"
+                                f"{' (+%d more)' % (len(missing_verify_cmds)-1) if len(missing_verify_cmds) > 1 else ''}"
+                                f". You have NOT run it. The external "
+                                f"verifier will use that exact command (or "
+                                f"equivalent) after you exit — run it NOW "
+                                f"yourself via `bash`, READ every failure "
+                                f"line, FIX what it reports, then rerun "
+                                f"until 0 failures. Your self-`verify` tool "
+                                f"checks YOUR criterion, not this command."
+                            )
                         elif last_verify_passed:
                             # 2026-06-04: model self-verified with its OWN
                             # criterion. Real tbench/pytest verifier runs
@@ -2576,7 +2660,13 @@ class AgentLoop:
         # Read-only checks (ls, pwd, git status) get a higher threshold.
         tool_name = tool_call.tool_name
         is_readonly = tool_name in ("grep", "read_file", "glob", "ls")
-        success_threshold = 6 if is_readonly else 4
+        # 2026-06-04: lowered read-only success threshold 6 → 3 after
+        # operator TUI session showed read_file looping 7× on the same
+        # file before circuit breaker fired. The tool already injects a
+        # "2nd identical read" header; if the model hasn't pivoted by
+        # the 3rd call, it never will. Cuts wasted-turn cost on stuck
+        # models from ~6 to ~3 per loop.
+        success_threshold = 3 if is_readonly else 4
 
         if is_failed and count >= 2:
             pass  # will be blocked below

{drydock_cli-2.9.57 → drydock_cli-2.9.59}/drydock/core/tools/builtins/write_file.py

@@ -451,6 +451,27 @@ class WriteFile(
         # triggers panic-retry loops (feedback_no_tool_errors_for_loop_detection).
         if not args.path.strip():
             cwd = Path.cwd()
+            # Track consecutive missing-path attempts so the advisory can
+            # escalate from gentle → concrete-suggestion → hard-block.
+            # 2026-06-04: operator reported 3+ identical missing-path
+            # attempts in TUI session — the soft advisory wasn't enough.
+            miss_state = self.state.__dict__.setdefault(
+                "_write_file_missing_path_streak", 0
+            )
+            miss_state += 1
+            self.state.__dict__["_write_file_missing_path_streak"] = miss_state
+
+            # Pull last-read paths from the read-file state for concrete
+            # suggestions on retry.
+            read_state = ctx.read_file_state if ctx else None
+            recent_reads: list[str] = []
+            if read_state:
+                try:
+                    # read_file_state is keyed by path; pull a stable list
+                    recent_reads = list(read_state.keys())[-3:]
+                except Exception:
+                    pass
+
             try:
                 pkg_dirs = [
                     d.name for d in sorted(cwd.iterdir())
@@ -459,29 +480,56 @@ class WriteFile(
                 hint = f"Package dirs in {cwd.name}/: {', '.join(pkg_dirs)}" if pkg_dirs else f"cwd: {cwd}"
             except OSError:
                 hint = f"cwd: {cwd}"
-            # 2026-05-31: do NOT echo a sample call shape in the error
-            # content. Gemma 4 copies whatever it sees from prior tool
-            # results as the next call's args — a literal call-syntax
-            # template in the error message gets re-emitted as the next
-            # call (operator session 2026-05-31 hit 5+ identical
-            # empty-path errors in a row). Keep the error terse and
-            # actionable; the tool schema in the system prompt is the
-            # canonical reference, not the error message. Same
-            # root-cause as the search_replace empty-call loop fixed
-            # via dedup-strip in commit dee310a.
-            yield WriteFileResult(
-                path="(missing)",
-                bytes_written=0,
-                file_existed=False,
-                content=(
+
+            if miss_state == 1:
+                # 2026-05-31: do NOT echo a sample call shape in the
+                # error content. Gemma 4 copies whatever it sees from
+                # prior tool results as the next call's args — a
+                # literal call-syntax template in the error message
+                # gets re-emitted as the next call. Keep terse.
+                msg = (
                     f"NO path supplied. Pick a concrete file path "
                     f"under the current project (e.g. one of the "
                     f"existing source files you just read), then "
                     f"re-emit the call with that path and the full "
                     f"file content. {hint}."
-                ),
+                )
+            elif miss_state == 2 and recent_reads:
+                # Escalate: name the actual recently-read files so the
+                # model has a concrete target. Removes ambiguity that
+                # caused the model to retry with the same empty args.
+                msg = (
+                    f"[REPEAT #{miss_state}] write_file STILL called with "
+                    f"NO path. Stop guessing — pick ONE of these files "
+                    f"you just read and pass its FULL absolute path as "
+                    f"`path`: {', '.join(recent_reads[:3])}. If none "
+                    f"of these is right, call read_file on the file "
+                    f"you intend to edit FIRST, then write_file with "
+                    f"that exact path."
+                )
+            else:
+                # 3rd+ miss with no recoverable suggestion. Block harder
+                # so the agent loop's "no progress" detector kicks in.
+                msg = (
+                    f"[HARD-BLOCK] write_file called with NO path "
+                    f"{miss_state} times in a row. STOP calling "
+                    f"write_file. Do one of: (1) call read_file on the "
+                    f"file you intend to edit so its path enters my "
+                    f"context, (2) call bash with `ls` or `find` to "
+                    f"locate the target file, (3) end your turn with a "
+                    f"text summary if you're stuck. Continuing to call "
+                    f"write_file without a path will produce this same "
+                    f"block — it is not progress."
+                )
+            yield WriteFileResult(
+                path="(missing)",
+                bytes_written=0,
+                file_existed=False,
+                content=msg,
             )
             return
+        # Reset the missing-path streak on a successful path arg.
+        self.state.__dict__["_write_file_missing_path_streak"] = 0
         file_path, file_existed, content_bytes = self._prepare_and_validate_path(args)
 
         # Read-before-Write enforcement (Claude Code tool contract).

{drydock_cli-2.9.57 → drydock_cli-2.9.59}/pyproject.toml

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