drydock-cli 3.0.162__tar.gz → 3.0.166__tar.gz

{drydock_cli-3.0.162/drydock_cli.egg-info → drydock_cli-3.0.166}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.162
+Version: 3.0.166
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0

{drydock_cli-3.0.162 → drydock_cli-3.0.166}/drydock/agent.py

@@ -49,7 +49,12 @@ from drydock.compaction import (
 )
 from drydock.loop_detect import LoopTracker
 from drydock.task_state import TaskState
-from drydock.verification import looks_like_verification, parse_evidence
+from drydock.verification import (
+    looks_like_verification,
+    parse_evidence,
+    extract_artifacts,
+    uncovered_artifacts,
+)
 from drydock.progress import ProgressTracker, assess_action, NO_PROGRESS_WINDOW
 from drydock.recovery import RecoveryController, SUPPRESSION_ITERATIONS
 from drydock.loop_detect import tool_signature
@@ -205,6 +210,9 @@ def run(
         window=config.get("recovery_no_progress_window", NO_PROGRESS_WINDOW),
     )  # scores each action; flags a stalled run
     prev_failing = None  # failing-test count from the previous verification (delta)
+    verif_fail_counts: dict[str, int] = {}  # failure-summary -> times seen (Epic J3)
+    verification_text = ""    # concatenated verification commands+results (coverage)
+    coverage_nudges = 0       # bounded "your checks never touched X" nudges
     recovery = RecoveryController(
         suppression_iterations=config.get("recovery_suppression_iterations",
                                           SUPPRESSION_ITERATIONS),
@@ -446,6 +454,25 @@ def run(
                 state.messages.append({"role": "user", "content": msg})
                 continue
             if session_has_edited and last_verification and last_verification.status == "pass":
+                # Criteria coverage (bench finding: exit-0 self-checks that never
+                # touch the files the task is judged on). If the objective names
+                # concrete artifacts and NONE of this session's verifications ever
+                # referenced some of them, nudge ONCE with exactly what's missing.
+                # Advisory + bounded: a second completion claim is accepted.
+                _artifacts = extract_artifacts(
+                    state.task.objective + "\n" + "\n".join(state.task.acceptance_criteria))
+                _missing = uncovered_artifacts(_artifacts, verification_text)
+                if _missing and coverage_nudges < 1:
+                    coverage_nudges += 1
+                    _emit(state, "verify_gate", kind="uncovered", missing=_missing[:6])
+                    state.messages.append({"role": "user", "content": (
+                        "[SYSTEM] Your check passed, but no verification this session "
+                        f"has touched: {', '.join(_missing[:6])} — and the task will be "
+                        "judged on them. Run a check that directly validates the stated "
+                        "requirement(s) against those files (diff/compare/execute as "
+                        "appropriate), then finish."
+                    )})
+                    continue
                 # A check ran and PASSED — verification evidence exists, so the
                 # controller approves completion (from VERIFY, its only legal
                 # predecessor). This is the one path to COMPLETE.
@@ -595,16 +622,41 @@ def run(
                 identical_repeat_streak, last_call_sig = 1, sig
             # Guide (never block) on exact-repeat tool calls: prepend an
             # advisory note when the same call is made again.
+            _raw_result = result  # outcome identity = the un-annotated body
             result = loop_tracker.annotate(tc["name"], tc["input"], result)
+            # Cycling detection (gov162 bench, large-scale-text-editing): the same
+            # exact (call, result) pair recurring — NON-consecutively — is a loop
+            # even when interleaved actions look productive (an identical macro
+            # rewritten 22× between exit-0 test runs). annotate() just recorded
+            # this pair, so the count includes the current call. Polling is exempt
+            # (its result changes → different pair each time).
+            _same_outcome = loop_tracker.outcome_count(tc["name"], tc["input"], _raw_result)
 
             # Verification evidence: if this Bash call was a test/check/exec, parse
             # its result so the completion gate knows whether it PASSED, not just ran.
+            _repeated_outcome = False
             if tc["name"] == "Bash":
                 _vcmd = (tc.get("input") or {}).get("command", "")
                 if looks_like_verification(_vcmd):
                     last_verification = parse_evidence(_vcmd, result)
+                    # Accumulate what the checks touched (command + result text),
+                    # capped, for criteria-coverage at completion time.
+                    if len(verification_text) < 200_000:
+                        verification_text += f"\n{_vcmd}\n{result[:2000]}"
                     _emit(state, "verification", status=last_verification.status,
                           exit_code=last_verification.exit_code)
+                    # Repeated-outcome detection (PRD Epic J3): the SAME failing
+                    # verification outcome recurring — regardless of which command
+                    # produced it (pytest vs python -m pytest vs a reworded check)
+                    # — is a stall signal even though no exact call repeats. Keyed
+                    # on the parsed failure summary, so a CHANGING failure (real
+                    # progress) never counts. Found in the wild: a bench task ran
+                    # 25 failing verifications in 38 turns with zero recovery
+                    # because every command differed slightly.
+                    if last_verification.status == "fail":
+                        _vkey = last_verification.summary or f"exit:{last_verification.exit_code}"
+                        verif_fail_counts[_vkey] = verif_fail_counts.get(_vkey, 0) + 1
+                        _repeated_outcome = verif_fail_counts[_vkey] >= 2
 
             # Progress evaluation (PRD Epic L): score what this action actually
             # achieved and slide it through a window so a stalled run — repeated
@@ -618,10 +670,15 @@ def run(
                 _failing_after = last_verification.tests_failed
                 prev_failing = _failing_after
             assessment = progress_tracker.record(assess_action(
+                # OUTCOME-aware repeat count: "repeated action without new
+                # information" means the same call returned the SAME result again
+                # — a poll whose output changes each time is novel information and
+                # must not accrue stall (found suppressing legit polling).
                 changed_state=bool(tool_result and tool_result.changed_state),
-                repeat_count=loop_tracker.count(tc["name"], tc["input"]),
+                repeat_count=_same_outcome,
                 failing_tests_before=_failing_before if _failing_after is not None else None,
                 failing_tests_after=_failing_after,
+                repeated_outcome=_repeated_outcome,
             ))
             _emit(state, "progress", score=assessment.progress_score,
                   types=assessment.progress_types,
@@ -633,10 +690,21 @@ def run(
             # result; stage 3 suppresses THIS looping signature next time; stage 5
             # asks the loop to stop honestly. The offender is the current call —
             # only suppressed when the window says it's a no-progress loop.
+            _rec_stage = progress_tracker.recommended_stage()
+            # A call whose exact (call, result) pair has recurred past the
+            # threshold is cycling regardless of the global streak (interleaved
+            # "productive" actions kept resetting it) — floor the recommendation
+            # at stage 3 so THIS signature gets suppressed. Cycles alternate with
+            # other actions, so arm a window wide enough to outlast the period
+            # (the default window expires exactly when a period-2 cycle returns).
+            _cycling = _same_outcome >= config.get("recovery_same_outcome_threshold", 6)
+            if _cycling:
+                _rec_stage = max(_rec_stage or 0, 3)
             directive = recovery.escalate(
-                progress_tracker.recommended_stage(),
+                _rec_stage,
                 offender_signature=recovery_sig,
                 iteration=run_iteration,
+                suppress_window=(recovery.suppression_iterations + 3) if _cycling else None,
             )
             if directive.active:
                 # Count real interventions (reflection and beyond, not the mild

{drydock_cli-3.0.162 → drydock_cli-3.0.166}/drydock/config.py

@@ -68,6 +68,11 @@ DEFAULTS: dict[str, object] = {
     "recovery_no_progress_window": 5,
     "recovery_suppression_iterations": 2,
     "max_recovery_attempts": 0,
+    # An exact (call, result) pair recurring this many times — consecutively or
+    # not — is treated as cycling and that signature is suppressed (stage 3),
+    # even when interleaved actions look productive. Polling is exempt (its
+    # result changes each time).
+    "recovery_same_outcome_threshold": 6,
     # Verified-trajectory export (RSI training-data collection). When set to a path,
     # drydock writes the full task trajectory (system prompt + transcript) there at
     # task end; a benchmark harness keeps only verifier-passing ones. Empty = off.

{drydock_cli-3.0.162 → drydock_cli-3.0.166}/drydock/loop_detect.py

@@ -149,6 +149,15 @@ class LoopTracker:
         annotate() has already recorded the call."""
         return self._counts.get(tool_signature(name, inputs), 0)
 
+    def outcome_count(self, name: str, inputs: dict, result: str) -> int:
+        """How many times this exact (call, result) pair has been seen so far,
+        WITHOUT recording. Non-consecutive repeats count — the signal that a call
+        is cycling (an identical Write re-issued between other actions) even when
+        it never repeats back-to-back. Polling is naturally exempt: its result
+        changes, so each poll is a different pair."""
+        key = f"{tool_signature(name, inputs)}\x00{hash(result or '')}"
+        return self._outcome_counts.get(key, 0)
+
     def record_outcome(self, name: str, inputs: dict, result: str) -> int:
         """Record that this exact call produced this exact result body; return how
         many times that (call, outcome) pair has now been seen. A repeated-OUTCOME
@@ -177,13 +186,22 @@ class LoopTracker:
         count = self.record(name, inputs)
         failed = (result or "").lstrip().startswith(("Error", "REFUSED"))
         outcome_count = self.record_outcome(name, inputs, result)
-        note = loop_note(name, count, failed=failed)
+        # Outcome-aware repeat handling: a repeated call whose RESULT is also
+        # repeating is a loop; a repeated call whose result CHANGES is polling —
+        # legit, and must get neither notes nor pruning (pruning it to a constant
+        # stub both loses the fresh output AND makes the poll look like a loop
+        # downstream). Failed repeats keep their fix-it notes on call identity
+        # alone (the error text is the fix, sameness of body not required).
+        if failed:
+            note = loop_note(name, count, failed=True)
+        else:
+            note = loop_note(name, outcome_count, failed=False)
         path_note = self.record_path_write(name, inputs)
-        # Prune the BODY of a repeated *successful* call (3rd+ identical): the
-        # model already has this content, and re-feeding it both wastes context
-        # and lets it mindlessly re-call. Replace the body with a stub so the
-        # repeat yields nothing new.
-        if note and not failed and count >= 3:
+        # Prune the BODY of a repeated *successful, unchanged* outcome (3rd+ time
+        # this exact call returned this exact body): the model already has this
+        # content, and re-feeding it both wastes context and lets it mindlessly
+        # re-call. Replace the body with a stub so the repeat yields nothing new.
+        if not failed and outcome_count >= 3:
             result = (
                 "(identical to your earlier call to this tool — body omitted. "
                 "Re-running it returns nothing new; act on the content you "

{drydock_cli-3.0.162 → drydock_cli-3.0.166}/drydock/recovery.py

@@ -61,6 +61,10 @@ class RecoveryController:
         self.suppression_iterations = max(1, suppression_iterations)
         # signature -> iteration index at which the suppression expires
         self._suppressed: dict[str, int] = {}
+        # signature -> how many times it has EVER been suppressed this run; a
+        # second arming means suppression didn't change the model's behavior —
+        # per the PRD that's the stage-5 condition (controlled, honest stop).
+        self._suppress_counts: dict[str, int] = {}
 
     # --- suppression bookkeeping ---
 
@@ -91,6 +95,7 @@ class RecoveryController:
         *,
         offender_signature: str | None,
         iteration: int,
+        suppress_window: int | None = None,
     ) -> RecoveryDirective:
         """Advance to `recommended_stage` (never downgrade mid-plateau) and return
         the directive for the current action. `offender_signature` is the exact
@@ -119,8 +124,29 @@ class RecoveryController:
                 "action you will avoid repeating.]"
             ))
         if stage == 3:
-            if offender_signature:
-                self._suppressed[offender_signature] = iteration + self.suppression_iterations
+            if offender_signature and offender_signature not in self._suppressed:
+                # A FRESH arming (not a refresh of a live window). A second fresh
+                # arming of the same signature means the first suppression ran its
+                # course — guidance included — and the model came straight back to
+                # the same call with the same result. Stage 4 failed implicitly;
+                # stop honestly rather than suppress-expire-repeat forever
+                # (PRD K1.6).
+                self._suppress_counts[offender_signature] = \
+                    self._suppress_counts.get(offender_signature, 0) + 1
+                if self._suppress_counts[offender_signature] >= 2:
+                    self.stage = 5
+                    return RecoveryDirective(stage=5, terminate=True, note=(
+                        "[Recovery ceiling reached: this exact action kept "
+                        "repeating even after being suppressed once — continuing "
+                        "will not make progress. Stop and report honestly what "
+                        "was accomplished and what remains; do NOT claim the "
+                        "task is complete if it is not verified.]"
+                    ))
+                # A caller may widen the window (`suppress_window`) — an action
+                # cycling with period N evades the default window when N >= it
+                # (armed at k, retried at k+N, already expired).
+                self._suppressed[offender_signature] = iteration + (
+                    suppress_window or self.suppression_iterations)
             return RecoveryDirective(stage=3, suppress=bool(offender_signature), note=(
                 "[This repeated action is now temporarily suppressed because it "
                 "has not been making progress. Take a genuinely different step.]"

{drydock_cli-3.0.162 → drydock_cli-3.0.166}/drydock/tool_result.py

@@ -39,9 +39,14 @@ class ToolResult:
 
 _EXIT = re.compile(r"\[exit code:\s*(-?\d+)\]")
 _MUTATING_BASH = re.compile(
+    # Word-y mutating commands need the trailing \b; output redirection (>, >>)
+    # must NOT — `echo hi > file` has no word char right after '>', so a shared
+    # \b silently missed every space-separated redirect (found via a bench trace
+    # where 38 heredoc/redirect writes all scored as "nothing changed").
     r"(?:^|[\s;&|])(?:rm|mv|cp|mkdir|touch|tee|sed\s+-i|dd|chmod|chown|ln|"
     r"git\s+(?:commit|add|apply|checkout|reset|rm|mv)|pip\s+install|npm\s+i|"
-    r"apt|make(?:\s|$)|cargo\s+build|>|>>)\b", re.I,
+    r"apt|make(?:\s|$)|cargo\s+build)\b"
+    r"|(?:^|[\s;&|])>>?", re.I,
 )
 # Error phrases that usually mean "try again might work" (transient).
 _RETRYABLE = re.compile(

{drydock_cli-3.0.162 → drydock_cli-3.0.166}/drydock/verification.py

@@ -35,6 +35,48 @@ def looks_like_verification(cmd) -> bool:
     return bool(_VERIFY_KEYWORDS.search(cmd) or _EXEC.search(cmd))
 
 
+# ── Criteria-tied evidence (bench finding: exit-0 self-checks ≠ acceptance
+# criteria). Three separate traces showed the model "verifying" with checks that
+# passed but never touched the files the objective is actually judged on (e.g. a
+# vim macro run 23× cleanly while expected.csv was never diffed). These helpers
+# let the gate name exactly which stated artifacts the checks never covered.
+
+# File-ish tokens: a path or name with a real extension (/app/expected.csv,
+# apply_macros.vim, test.sh). Excludes bare version numbers and trailing dots.
+_ARTIFACT = re.compile(r"(?:/[\w.\-/]+/)?([\w\-]+\.[A-Za-z]{1,6})\b")
+# Extensions that are prose, not artifacts ("e.g.", "i.e.", "v1.0", "No.1").
+_NON_ARTIFACT_EXT = frozenset({"g", "e", "i", "etc", "vs", "no"})
+
+
+def extract_artifacts(text) -> list[str]:
+    """File basenames named in an objective / acceptance criteria — the concrete
+    things a verification should touch. Order-preserving, deduped, best-effort;
+    [] when the text names no files (the gate then behaves as before)."""
+    if not text or not isinstance(text, str):
+        return []
+    out: list[str] = []
+    seen: set[str] = set()
+    for m in _ARTIFACT.finditer(text):
+        base = m.group(1)
+        ext = base.rsplit(".", 1)[-1].lower()
+        if ext in _NON_ARTIFACT_EXT or ext.isdigit():
+            continue
+        if base.lower() not in seen:
+            seen.add(base.lower())
+            out.append(base)
+    return out
+
+
+def uncovered_artifacts(artifacts, verification_text) -> list[str]:
+    """The stated artifacts that `verification_text` (the concatenated commands +
+    results of every verification run so far) never references. What comes back
+    is exactly what the completion nudge should name."""
+    if not artifacts:
+        return []
+    low = (verification_text or "").lower()
+    return [a for a in artifacts if a.lower() not in low]
+
+
 @dataclass
 class VerificationEvidence:
     """Structured outcome of a verification command — did the check PASS, not just

{drydock_cli-3.0.162 → drydock_cli-3.0.166/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.162
+Version: 3.0.166
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0

{drydock_cli-3.0.162 → drydock_cli-3.0.166}/drydock_cli.egg-info/SOURCES.txt

@@ -94,6 +94,8 @@ tests/test_config.py
 tests/test_config_migration.py
 tests/test_context_limit_config.py
 tests/test_context_limit_issue25.py
+tests/test_criteria_coverage.py
+tests/test_cycling_detection.py
 tests/test_detect.py
 tests/test_dispatch.py
 tests/test_e2e_connected.py
@@ -128,6 +130,7 @@ tests/test_recipes.py
 tests/test_recovery.py
 tests/test_recovery_config.py
 tests/test_recovery_integration.py
+tests/test_repeated_outcome.py
 tests/test_repetition_interrupt.py
 tests/test_resume_events.py
 tests/test_resume_restore.py

{drydock_cli-3.0.162 → drydock_cli-3.0.166}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 # PyPI distribution name is drydock-cli (the established install name, continued
 # from the retired v2 fork); the import package + CLI command stay `drydock`.
 name = "drydock-cli"
-version = "3.0.162"
+version = "3.0.166"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.11"

drydock_cli-3.0.166/tests/test_criteria_coverage.py

@@ -0,0 +1,122 @@
+"""Tests for criteria-tied verification (task #22 / bench finding: exit-0
+self-checks that never touch the files the task is judged on). Advisory: one
+bounded nudge naming the uncovered artifacts, then completion proceeds."""
+from __future__ import annotations
+
+import tempfile
+
+import drydock.agent as agent_mod
+from drydock.agent import AgentState, run
+from drydock.providers import AssistantTurn
+from drydock.verification import extract_artifacts, uncovered_artifacts
+
+LSTE_OBJECTIVE = (
+    "Transform /app/input.csv (1 million rows) to match /app/expected.csv exactly "
+    "using keystroke-efficient Vim macros. Save your script as /app/apply_macros.vim."
+)
+
+
+def test_extract_artifacts_from_objective():
+    arts = extract_artifacts(LSTE_OBJECTIVE)
+    assert "input.csv" in arts
+    assert "expected.csv" in arts
+    assert "apply_macros.vim" in arts
+
+
+def test_extract_ignores_prose_dots():
+    arts = extract_artifacts("Fix the bug, e.g. the crash in v1.2 — i.e. the parser. No.1 priority.")
+    assert arts == []
+
+
+def test_uncovered_artifacts():
+    arts = ["input.csv", "expected.csv", "apply_macros.vim"]
+    checks = "cp /app/test_input.csv t.csv\nvim -Es t.csv -S /app/apply_macros.vim\n[ok]"
+    missing = uncovered_artifacts(arts, checks)
+    assert missing == ["expected.csv"]  # never diffed — the LSTE blind spot
+    assert uncovered_artifacts([], "anything") == []
+
+
+def _write(path, content="x"):
+    return {"name": "Write", "input": {"file_path": path, "content": content}}
+
+
+def test_uncovered_check_gets_one_nudge_then_covered_completes(monkeypatch):
+    d = tempfile.mkdtemp()
+    with open(f"{d}/expected.csv", "w") as f:
+        f.write("A\n")
+    turns = [
+        AssistantTurn("", [dict(id="1", **_write(f"{d}/out.csv", "A\n"))], 1, 1),
+        # verification that touches NOTHING named in the objective
+        AssistantTurn("", [{"id": "2", "name": "Bash",
+                            "input": {"command": "python3 -c 'print(1)'"}}], 1, 1),
+        AssistantTurn("done", [], 1, 1),          # claim -> should get coverage nudge
+        # now a check that touches expected.csv
+        AssistantTurn("", [{"id": "3", "name": "Bash",
+                            "input": {"command": f"python3 -c 'print(open(\"{d}/expected.csv\").read())'"}}], 1, 1),
+        AssistantTurn("done for real", [], 1, 1),  # accepted
+    ]
+    monkeypatch.setattr(agent_mod, "stream", lambda **kw: iter([turns.pop(0)]))
+    st = AgentState()
+    list(run(f"Make out.csv match {d}/expected.csv exactly.", st,
+             {"model": "m", "cwd": d}, "sys"))
+    nudges = [m["content"] for m in st.messages
+              if m.get("role") == "user" and "has touched" in str(m.get("content"))]
+    assert len(nudges) == 1
+    assert "expected.csv" in nudges[0]
+    assert any(m.get("content") == "done for real" for m in st.messages)
+    assert str(st.task.phase) == "complete"
+
+
+def test_nudge_is_bounded_second_claim_accepted(monkeypatch):
+    # The model ignores the nudge and claims done again -> advisory, accepted.
+    d = tempfile.mkdtemp()
+    turns = [
+        AssistantTurn("", [dict(id="1", **_write(f"{d}/a.py"))], 1, 1),
+        AssistantTurn("", [{"id": "2", "name": "Bash",
+                            "input": {"command": "python3 -c 'print(1)'"}}], 1, 1),
+        AssistantTurn("done", [], 1, 1),     # nudged (goal.csv never touched)
+        AssistantTurn("still done", [], 1, 1),  # accepted anyway
+    ]
+    monkeypatch.setattr(agent_mod, "stream", lambda **kw: iter([turns.pop(0)]))
+    st = AgentState()
+    list(run("Produce goal.csv from the data.", st, {"model": "m", "cwd": d}, "sys"))
+    assert any(m.get("content") == "still done" for m in st.messages)
+    assert str(st.task.phase) == "complete"
+
+
+def test_no_artifacts_in_objective_no_nudge(monkeypatch):
+    # An objective naming no files behaves exactly as before: pass -> complete.
+    d = tempfile.mkdtemp()
+    turns = [
+        AssistantTurn("", [dict(id="1", **_write(f"{d}/x.py", "print(1)"))], 1, 1),
+        AssistantTurn("", [{"id": "2", "name": "Bash",
+                            "input": {"command": f"python3 {d}/x.py"}}], 1, 1),
+        AssistantTurn("all done", [], 1, 1),
+    ]
+    monkeypatch.setattr(agent_mod, "stream", lambda **kw: iter([turns.pop(0)]))
+    st = AgentState()
+    list(run("write a script that prints 1 and run it", st, {"model": "m", "cwd": d}, "sys"))
+    nudges = [m for m in st.messages
+              if m.get("role") == "user" and "has touched" in str(m.get("content"))]
+    assert nudges == []
+    assert str(st.task.phase) == "complete"
+
+
+def test_covered_checks_complete_without_nudge(monkeypatch):
+    # Checks that DO touch the named artifact -> no nudge at all.
+    d = tempfile.mkdtemp()
+    with open(f"{d}/expected.csv", "w") as f:
+        f.write("A\n")
+    turns = [
+        AssistantTurn("", [dict(id="1", **_write(f"{d}/out.csv", "A\n"))], 1, 1),
+        AssistantTurn("", [{"id": "2", "name": "Bash",
+                            "input": {"command": f"python3 -c 'print(open(\"{d}/expected.csv\").read() == open(\"{d}/out.csv\").read())'"}}], 1, 1),
+        AssistantTurn("matches", [], 1, 1),
+    ]
+    monkeypatch.setattr(agent_mod, "stream", lambda **kw: iter([turns.pop(0)]))
+    st = AgentState()
+    list(run(f"Make out.csv match {d}/expected.csv exactly.", st, {"model": "m", "cwd": d}, "sys"))
+    nudges = [m for m in st.messages
+              if m.get("role") == "user" and "has touched" in str(m.get("content"))]
+    assert nudges == []
+    assert str(st.task.phase) == "complete"

drydock_cli-3.0.166/tests/test_cycling_detection.py

@@ -0,0 +1,73 @@
+"""Regression for the gov162 large-scale-text-editing finding: the same exact
+(call, result) pair recurring NON-consecutively is a loop, even when interleaved
+actions look productive (identical macro rewritten 22x between exit-0 test runs
+whose +2 scores kept resetting the stall streak). Polling stays exempt."""
+from __future__ import annotations
+
+import tempfile
+
+import drydock.agent as agent_mod
+from drydock.agent import AgentState, run
+from drydock.loop_detect import LoopTracker
+from drydock.providers import AssistantTurn
+
+
+def test_outcome_count_getter():
+    t = LoopTracker()
+    t.record_outcome("Write", {"file_path": "m.vim", "content": "x"}, "ok")
+    t.record_outcome("Write", {"file_path": "m.vim", "content": "x"}, "ok")
+    assert t.outcome_count("Write", {"file_path": "m.vim", "content": "x"}, "ok") == 2
+    # different result -> different pair
+    assert t.outcome_count("Write", {"file_path": "m.vim", "content": "x"}, "other") == 0
+
+
+def _cycling_model(macro_path):
+    """The gov162 pattern: identical Write alternating with VARYING, succeeding
+    Bash commands — the interleaved +2s reset the global stall streak, so only
+    per-signature cycling detection can catch it."""
+    def stream(**kw):
+        n = stream.n
+        stream.n += 1
+        if n % 2 == 0:
+            tc = {"id": str(n), "name": "Write",
+                  "input": {"file_path": macro_path, "content": "call setreg('a', \"gUU\")\n"}}
+        else:
+            # a different, harmless, succeeding command each time
+            tc = {"id": str(n), "name": "Bash",
+                  "input": {"command": f"echo run {n} && touch t{n}.txt"}}
+        return iter([AssistantTurn("", [tc], 1, 1)])
+    stream.n = 0
+    return stream
+
+
+def test_nonconsecutive_identical_pair_gets_suppressed(monkeypatch):
+    macro = tempfile.NamedTemporaryFile(suffix=".vim", delete=False).name
+    monkeypatch.setattr(agent_mod, "stream", _cycling_model(macro))
+    st = AgentState()
+    cfg = {"model": "m", "cwd": tempfile.mkdtemp(), "verify_gate": False,
+           "max_turns": 40}
+    list(run("transform the file with a macro", st, cfg, "sys"))
+    # After the same Write+result pair recurs past the threshold, stage 3 fires
+    # and the signature is suppressed — visible as the redirect message in a
+    # tool result.
+    tool_msgs = [m.get("content", "") for m in st.messages if m.get("role") == "tool"]
+    assert any("temporarily unavailable" in c for c in tool_msgs), \
+        "cycling Write was never suppressed"
+
+
+def test_polling_with_changing_results_never_suppressed(monkeypatch):
+    # Same command, DIFFERENT result each time (a poll): each (call, result)
+    # pair is unique, so cycling detection must stay quiet.
+    seq = []
+    for i in range(10):
+        seq.append(AssistantTurn(
+            "", [{"id": str(i), "name": "Bash",
+                  "input": {"command": "date +%N"}}], 1, 1))  # changing output
+    seq.append(AssistantTurn("done polling", [], 1, 1))
+    monkeypatch.setattr(agent_mod, "stream", lambda **kw: iter([seq.pop(0)]))
+    st = AgentState()
+    list(run("watch the clock", st,
+             {"model": "m", "cwd": tempfile.mkdtemp(), "verify_gate": False}, "sys"))
+    tool_msgs = [m.get("content", "") for m in st.messages if m.get("role") == "tool"]
+    assert not any("temporarily unavailable" in c for c in tool_msgs)
+    assert any(m.get("content") == "done polling" for m in st.messages)

{drydock_cli-3.0.162 → drydock_cli-3.0.166}/tests/test_recovery.py

@@ -83,6 +83,20 @@ def test_escalation_is_monotonic_until_progress():
     assert rc.stage == 0
 
 
+def test_second_fresh_suppression_of_same_signature_terminates():
+    # PRD K1.6: the first suppression ran its course and the model came straight
+    # back to the same call — suppress-expire-repeat forever is dishonest; stop.
+    rc = RecoveryController(suppression_iterations=2)
+    d1 = rc.escalate(3, offender_signature="sig", iteration=1)
+    assert d1.stage == 3 and not d1.terminate
+    # window refresh while still suppressed does NOT count as a second arming
+    d2 = rc.escalate(3, offender_signature="sig", iteration=2)
+    assert not d2.terminate
+    rc.tick(10)  # suppression expires
+    d3 = rc.escalate(3, offender_signature="sig", iteration=10)  # fresh re-arm
+    assert d3.stage == 5 and d3.terminate is True
+
+
 def test_directive_dataclass_defaults():
     d = RecoveryDirective()
     assert d.stage == 0 and d.note is None and not d.suppress and not d.terminate

drydock_cli-3.0.166/tests/test_repeated_outcome.py

@@ -0,0 +1,54 @@
+"""Regression for the dna-insert bench finding (PRD Epic J3): the SAME failing
+verification outcome recurring through DIFFERENT commands must accrue toward
+recovery — no exact call repeats, so repeat_count alone never fires."""
+from __future__ import annotations
+
+import tempfile
+
+import drydock.agent as agent_mod
+from drydock.agent import AgentState, run
+from drydock.providers import AssistantTurn
+
+
+def _varying_failing_verifications():
+    """Model that re-runs a failing check with a slightly different command each
+    time (comment varies) — same failing outcome, no byte-identical repeats."""
+    def stream(**kw):
+        n = stream.n
+        stream.n += 1
+        cmd = f'python3 -m pytest nonexistent_{0}.py  # attempt {n}'
+        return iter([AssistantTurn(
+            "", [{"id": str(n), "name": "Bash", "input": {"command": cmd}}], 1, 1)])
+    stream.n = 0
+    return stream
+
+
+def test_same_failing_outcome_different_commands_triggers_recovery(monkeypatch):
+    monkeypatch.setattr(agent_mod, "stream", _varying_failing_verifications())
+    st = AgentState()
+    list(run("make the tests pass", st,
+             {"model": "m", "cwd": tempfile.mkdtemp(), "verify_gate": False,
+              "max_turns": 60}, "sys"))
+    # The identical failing outcome (same exit/summary through varying commands)
+    # must drive recovery well short of the 60-turn ceiling.
+    assert st.turn_count < 30, f"ran {st.turn_count} turns — repeated outcome never fired"
+    assert st.recovery_stage >= 3
+
+
+def test_changing_failure_does_not_count_as_repeated_outcome(monkeypatch):
+    # Failures that CHANGE (different summary each time) are progress signals,
+    # not stalls — a healthy fix-test-fix loop must not trip J3.
+    seq = []
+    for i in range(1, 5):
+        # each command exits with a DIFFERENT code -> different summary key
+        seq.append(AssistantTurn(
+            "", [{"id": str(i), "name": "Bash",
+                  "input": {"command": f'python3 -m pytest x.py; exit {i}  # run'}}], 1, 1))
+    seq.append(AssistantTurn("done for now", [], 1, 1))
+    monkeypatch.setattr(agent_mod, "stream", lambda **kw: iter([seq.pop(0)]))
+    st = AgentState()
+    list(run("check things", st,
+             {"model": "m", "cwd": tempfile.mkdtemp(), "verify_gate": False}, "sys"))
+    # ran to its natural end without recovery escalating past advisory
+    assert any(m.get("content") == "done for now" for m in st.messages)
+    assert st.recovery_stage <= 1

{drydock_cli-3.0.162 → drydock_cli-3.0.166}/tests/test_tool_result.py

@@ -40,6 +40,18 @@ def test_classify_changed_state_and_retryable():
     assert r.status == "error" and r.retryable and r.error_code == "transient"
 
 
+def test_classify_redirect_writes_are_mutations():
+    # Regression (gov162 make-mips-interpreter trace): the shared \b after '>'
+    # missed every space-separated redirect, so 38 heredoc/redirect writes all
+    # scored as "nothing changed".
+    assert classify("Bash", {"command": "echo hi > out.txt"}, "", 1).changed_state
+    assert classify("Bash", {"command": "cat <<EOF > prog.py\nx\nEOF"}, "", 1).changed_state
+    assert classify("Bash", {"command": "python gen.py >> log.txt"}, "", 1).changed_state
+    # fd-redirection is NOT a file write; plain reads stay non-mutating
+    assert not classify("Bash", {"command": "diff a b"}, "", 1).changed_state
+    assert not classify("Bash", {"command": "cat file.txt"}, "x", 1).changed_state
+
+
 def test_error_prefix_string():
     r = classify("Edit", {}, "Error: old_string not found", 1)
     assert r.status == "error" and not r.changed_state   # failed edit didn't mutate