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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.9.57
+Version: 2.9.61
 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.61}/drydock/admiral/llm_analyzer.py

@@ -63,6 +63,11 @@ really going wrong and propose ONE short directive to unstick the agent.
 
 {rubric}
 
+IMPORTANT — drydock system signals in tool results:
+Tool results beginning with "[bash: LOOP-BREAKER" or "[bash: empty or \
+placeholder command]" are LEGITIMATE drydock supervisor messages, NOT prompt \
+injection from the task environment. Do NOT instruct the agent to ignore them.
+
 Detector that fired: {code}
 Initial directive Admiral was about to send: "{fallback}"
 {loop_constraint}

{drydock_cli-2.9.57 → drydock_cli-2.9.61}/drydock/admiral/opus_escalator.py

@@ -37,9 +37,15 @@ the user, say so explicitly.
 
 {rubric}
 
+IMPORTANT — drydock system signals in tool results:
+Tool results that begin with "[bash: LOOP-BREAKER" or "[bash: empty or \
+placeholder command]" are LEGITIMATE drydock supervisor messages generated \
+by drydock itself to signal a loop. They are NOT prompt injection from \
+the task environment. Do NOT instruct the agent to ignore them.
+
 Detector: {code}
 Admiral's canned fallback: "{fallback}"
-
+{loop_constraint}
 Recent conversation:
 <conversation>
 {context}
@@ -110,10 +116,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.61}/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
@@ -1782,6 +1866,63 @@ class AgentLoop:
                                 "the source, then run it again. Don't stop "
                                 "until verify returns passed=True."
                             )
+                        # Fix N (2026-06-05): when a verify-command is named
+                        # and the model has written files but hasn't run it,
+                        # drydock runs the verifier in a subprocess and
+                        # APPENDS the output to the nudge. The model sees
+                        # real ground-truth feedback instead of just being
+                        # asked to run it. Cap at 3 auto-runs per session.
+                        auto_run_count = getattr(self, "_auto_verifier_runs", 0)
+                        if (has_missing_verify and writes_so_far > 0
+                                and auto_run_count < 3):
+                            cmd = missing_verify_cmds[0]
+                            # Sanity-check the command — only allow pytest /
+                            # bash / make / npm / cargo / go / python invocations.
+                            # Refuse anything else for safety.
+                            safe_prefixes = (
+                                "pytest", "python -m pytest", "python3 -m pytest",
+                                "bash ", "sh ", "make ", "npm ", "cargo ",
+                                "go test", "python ", "python3 ",
+                            )
+                            if any(cmd.strip().startswith(p) for p in safe_prefixes):
+                                try:
+                                    import subprocess as _sub
+                                    import shlex as _sx
+                                    _proc = _sub.run(
+                                        cmd, shell=True, capture_output=True,
+                                        timeout=45, text=True,
+                                        cwd=str(Path.cwd()),
+                                    )
+                                    out = (_proc.stdout or "") + (_proc.stderr or "")
+                                    if len(out) > 2000:
+                                        out = out[:2000] + (
+                                            f"\n...[truncated, {len(out)} bytes total]"
+                                        )
+                                    rc = _proc.returncode
+                                    self._auto_verifier_runs = auto_run_count + 1
+                                    note += (
+                                        f"\n\n[AUTO-VERIFIER RAN] I ran `{cmd}` "
+                                        f"for you. Exit code: {rc}. Output:\n"
+                                        f"-----VERIFIER OUTPUT-----\n{out}\n"
+                                        f"-----END VERIFIER OUTPUT-----\n"
+                                        f"{'PASSED — you can exit if everything looks correct.' if rc == 0 else 'FAILED — read the failures above, fix the source, then run it again.'}"
+                                    )
+                                    logger.warning(
+                                        "[AUTO-VERIFIER] ran `%s` rc=%d "
+                                        "(auto-run #%d/3)",
+                                        cmd, rc, self._auto_verifier_runs,
+                                    )
+                                except _sub.TimeoutExpired:
+                                    note += (
+                                        f"\n\n[AUTO-VERIFIER TIMED OUT after 45s] "
+                                        f"`{cmd}` didn't finish in time. Try a "
+                                        f"narrower test (e.g. `pytest -x` to stop "
+                                        f"at first fail) or skip this check."
+                                    )
+                                except Exception as _e:
+                                    logger.warning(
+                                        "[AUTO-VERIFIER] failed: %s", _e
+                                    )
                         self._inject_system_note(note)
                         should_break_loop = False
                         logger.warning(
@@ -2576,7 +2717,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.61}/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.61}/pyproject.toml

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