drydock-cli 2.9.62__tar.gz → 2.9.67__tar.gz

{drydock_cli-2.9.62 → drydock_cli-2.9.67}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.9.62
+Version: 2.9.67
 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.62 → drydock_cli-2.9.67}/drydock/core/agent_loop.py

@@ -1706,6 +1706,15 @@ class AgentLoop:
                             # 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[^`]*)`",
+                            # Fix Q (2026-06-05): broaden detection — most tasks
+                            # mention "pytest" without backticks. e.g. "run
+                            # pytest", "tests use pytest", "verify with pytest".
+                            # Match bare command names that imply a verifier.
+                            r"\b(pytest(?:\s+-[a-zA-Z]+)?)\b",
+                            r"\b(python(?:3)?\s+-m\s+pytest(?:\s+-[a-zA-Z]+)?)\b",
+                            r"\b(python(?:3)?\s+-m\s+unittest)\b",
+                            r"\b(bash\s+[/\w.-]+\.sh)\b",
+                            r"\b(make\s+test|make\s+check)\b",
                         ]
                         for p in cmd_patterns:
                             for m in _re2.finditer(p, task_text, _re2.IGNORECASE):
@@ -1873,6 +1882,37 @@ class AgentLoop:
                         # 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)
+                        # Fix V (2026-06-05 cycle 1): fall back to discovering
+                        # test files even when the task doesn't name an explicit
+                        # verifier command. Cycle 1 batch on v2.9.65: Fix N
+                        # fired 0 times because the regex patterns required
+                        # specific phrases that few tasks contain. Many tbench
+                        # tasks have `/tests/test_*.py` files that pytest
+                        # discovers automatically — just running bare `pytest`
+                        # would surface them.
+                        if (not has_missing_verify and writes_so_far > 0
+                                and auto_run_count < 2):
+                            # No explicit command — try pytest in the trial cwd
+                            # as a generic fallback. Most tbench tasks use it.
+                            try:
+                                import subprocess as _sub_fb
+                                # Discover test files first so we don't run
+                                # pytest in /tmp with nothing.
+                                _disc = _sub_fb.run(
+                                    "find /app /tests -maxdepth 3 "
+                                    "\\( -name 'test_*.py' -o -name '*_test.py' "
+                                    "-o -name 'tests.py' \\) 2>/dev/null | head -5",
+                                    shell=True, capture_output=True,
+                                    timeout=5, text=True,
+                                )
+                                test_files = (_disc.stdout or "").strip()
+                                if test_files:
+                                    missing_verify_cmds = [
+                                        f"pytest -x {test_files.replace(chr(10), ' ')}"
+                                    ]
+                                    has_missing_verify = True
+                            except Exception:
+                                pass
                         if (has_missing_verify and writes_so_far > 0
                                 and auto_run_count < 3):
                             cmd = missing_verify_cmds[0]
@@ -2610,7 +2650,12 @@ class AgentLoop:
             except (OSError, AttributeError):
                 pass  # best-effort — fall through to normal threshold check
 
-        threshold = 5 if is_readonly else 8
+        # 2026-06-05: lowered readonly threshold 5 → 3 to match the FULL
+        # circuit breaker. Operator session showed read_file looping 5×
+        # on the same file in TUI before block fired here. The tool
+        # already injects a "2nd identical read" header; if the model
+        # hasn't pivoted by the 3rd call, it never will.
+        threshold = 3 if is_readonly else 8
         if count < threshold:
             return None
         # Increment so the count escalates on every repeated fire, giving the

{drydock_cli-2.9.62 → drydock_cli-2.9.67}/drydock/core/prompts/gemma4_slim.md

@@ -97,6 +97,9 @@ PROGRAMMATIC-MODE / BATCH TASKS:
 - After each WRITE/EDIT, VERIFY with a read_file or quick bash test before moving to the next step.
 - Multi-step tasks: keep tool calls flowing. If you find yourself thinking >30s between calls, emit the next concrete tool call with your best guess.
 
+WRITE THE LITERAL ANSWER FILE, NOT A SCRIPT THAT PRODUCES IT.
+When the task says "write the answer to /app/X.txt in [FORMAT]", call write_file with `path="/app/X.txt"` and `content="<your literal answer string>"`. Do NOT write a Python script that COMPUTES the answer — write the answer directly. Example: task says "write the best chess move to /app/move.txt in [src][dst] format". Correct: `write_file(path="/app/move.txt", content="e2e4\n")`. Wrong: writing `/app/solver.py` that prints the move. The verifier reads the file on disk; it doesn't execute your scripts. Helper code is only needed if the task explicitly asks for a script (e.g. "create a Python module that…").
+
 TEST QUALITY (when writing tests):
 1. Exact match, not keyword grep. Use `=` for exact lines, `diff` for multi-line. `grep -q "14"` passes for "14.0" too — that's a bug masker.
 2. Roundtrip properties. `decrypt(encrypt(x)) == x`, `parse(serialize(x)) == x`. Impossible to cheat.

{drydock_cli-2.9.62 → drydock_cli-2.9.67}/drydock/core/tools/builtins/write_file.py

@@ -451,24 +451,20 @@ 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.
+            # Make the response ROBUST and IMMEDIATE — name concrete
+            # recently-read files in the FIRST advisory. 2026-06-05:
+            # operator showed v2.9.59 streak-based escalation not
+            # kicking in (model saw 1st-miss message repeatedly).
+            # Suspect: streak state didn't persist reliably across
+            # tool-call boundaries. Stateless approach: every miss
+            # gets the full advisory + recent-reads suggestion +
+            # repeat-history awareness via the ctx.read_file_state
+            # signature. Strictly better than the streak version.
             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:]
+                    recent_reads = list(read_state.keys())[-5:]
                 except Exception:
                     pass
 
@@ -481,45 +477,37 @@ class WriteFile(
             except OSError:
                 hint = f"cwd: {cwd}"
 
-            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.
+            # Always include recent reads if available — eliminates
+            # ambiguity on the very first miss, not just on retries.
+            if recent_reads:
                 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."
+                    "NO `path` supplied to write_file. Pick ONE of "
+                    "these files you've recently read and pass its FULL "
+                    "absolute path as the `path` argument:\n  - "
+                    + "\n  - ".join(recent_reads[:5])
+                    + f"\n\nIf none of those is the file you intend to "
+                    f"edit, call read_file on the target file FIRST so "
+                    f"its path enters context, then call write_file "
+                    f"with `path` set to that exact path AND `content` "
+                    f"set to the full new file content. {hint}.\n\n"
+                    f"⚠ If you call write_file with NO path again you "
+                    f"will get this same advisory — that is NOT progress. "
+                    f"Switch to read_file, bash `ls`, or end your turn."
                 )
             else:
-                # 3rd+ miss with no recoverable suggestion. Block harder
-                # so the agent loop's "no progress" detector kicks in.
+                # No reads yet — must locate the target first.
                 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."
+                    "NO `path` supplied to write_file. You haven't read "
+                    "any files yet, so there is no obvious target. Do "
+                    "ONE of these:\n"
+                    "  1. Call `bash` with `ls` or `find` to locate the "
+                    "target file path under the current project\n"
+                    "  2. Call `read_file` on the file you intend to edit\n"
+                    "  3. End your turn with text if you're truly stuck\n"
+                    f"{hint}.\n\n"
+                    "⚠ Calling write_file again with NO path will "
+                    "produce this same advisory — not progress. Switch "
+                    "tools."
                 )
             yield WriteFileResult(
                 path="(missing)",
@@ -528,8 +516,6 @@ class WriteFile(
                 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.62 → drydock_cli-2.9.67}/pyproject.toml

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