drydock-cli 3.0.126__tar.gz → 3.0.128__tar.gz

{drydock_cli-3.0.126/drydock_cli.egg-info → drydock_cli-3.0.128}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.126
+Version: 3.0.128
 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.126 → drydock_cli-3.0.128}/drydock/agent.py

@@ -48,7 +48,7 @@ from drydock.compaction import (
 )
 from drydock.loop_detect import LoopTracker
 from drydock.task_state import TaskState
-from drydock.verification import looks_like_verification
+from drydock.verification import looks_like_verification, parse_evidence
 from drydock.events import emit as _emit
 from drydock.tuning import (
     filter_tool_schemas,
@@ -159,8 +159,8 @@ def run(
         return cancel is not None and cancel.is_set()
     tool_call_count = 0
     session_has_edited = False
-    ran_verification = False   # a test/check/exec command ran (verification gate)
-    verify_gate_nudges = 0     # bounded "verify before you finish" nudges
+    last_verification = None    # VerificationEvidence of the most recent check (gate)
+    verify_gate_nudges = 0      # bounded "verify before you finish" nudges
     leaked_call_retries = 0
     plan_continue_nudges = 0  # consecutive "you stopped mid-plan" nudges
     empty_response_nudges = 0  # consecutive "you returned nothing" nudges
@@ -347,32 +347,42 @@ def run(
             # If the agent CHANGED files but never ran a test/check/its own code,
             # don't accept completion — make it verify first. Bounded so it can't
             # wedge; once it runs any check (ran_verification) the gate is satisfied.
-            if (
+            # A text-only "done" after editing is accepted only when a check has
+            # PASSED. Never ran one → nudge to VERIFY. Ran one that FAILED → the work
+            # isn't done → nudge to REPAIR. Bounded so it can't wedge.
+            _needs_gate = (
                 config.get("verify_gate", True)
                 and allow is None            # main task only — not scoped sub-agents
                 and session_has_edited
-                and not ran_verification
                 and verify_gate_nudges < 2
-            ):
+                and (last_verification is None or last_verification.status == "fail")
+            )
+            if _needs_gate:
                 verify_gate_nudges += 1
-                state.task.phase = "verify"
-                _emit(state, "verify_gate", nudge=verify_gate_nudges)
-                state.messages.append({
-                    "role": "user",
-                    "content": (
+                if last_verification is None:
+                    state.task.phase = "verify"
+                    _emit(state, "verify_gate", kind="unverified", nudge=verify_gate_nudges)
+                    msg = (
                         "[SYSTEM] You changed files but have not VERIFIED the work. "
-                        "Before finishing, run a concrete check: the task's own test/"
-                        "eval/build (pytest, test.sh, make, npm test, …) or run the "
-                        "code/script you produced and confirm the output is correct "
-                        "and meets EVERY requirement. Do that now with a tool call; "
-                        "if it fails, fix it and re-check."
-                    ),
-                })
+                        "Run a concrete check now: the task's own test/eval/build "
+                        "(pytest, test.sh, make, npm test, …) or run the code you "
+                        "produced, and confirm it meets EVERY requirement."
+                    )
+                else:  # a check ran and FAILED
+                    state.task.phase = "repair"
+                    _emit(state, "verify_gate", kind="failed", nudge=verify_gate_nudges,
+                          summary=last_verification.summary)
+                    msg = (
+                        f"[SYSTEM] Your verification FAILED ({last_verification.summary}). "
+                        "The task is NOT complete. Read the failure, fix the cause, then "
+                        "re-run the SAME check until it passes."
+                    )
+                state.messages.append({"role": "user", "content": msg})
                 continue
-            if session_has_edited and ran_verification:
+            if session_has_edited and last_verification and last_verification.status == "pass":
                 state.task.phase = "complete"
             _emit(state, "done", phase=state.task.phase, edited=session_has_edited,
-                  verified=ran_verification)
+                  verified=bool(last_verification and last_verification.status == "pass"))
             break
 
         # Execute each tool call
@@ -380,10 +390,6 @@ def run(
             tool_call_count += 1
             if tc["name"] in ("Edit", "Write"):
                 session_has_edited = True
-            elif tc["name"] == "Bash" and looks_like_verification(
-                (tc.get("input") or {}).get("command", "")
-            ):
-                ran_verification = True  # the agent actually ran a test/check/its code
 
             # STOP pressed: don't run the remaining tools, but still record a
             # paired result for each (the assistant message already lists all
@@ -435,6 +441,15 @@ def run(
             # advisory note when the same call is made again.
             result = loop_tracker.annotate(tc["name"], tc["input"], 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.
+            if tc["name"] == "Bash":
+                _vcmd = (tc.get("input") or {}).get("command", "")
+                if looks_like_verification(_vcmd):
+                    last_verification = parse_evidence(_vcmd, result)
+                    _emit(state, "verification", status=last_verification.status,
+                          exit_code=last_verification.exit_code)
+
             _emit(state, "tool", name=tc["name"],
                   input=str(tc.get("input"))[:200],
                   result_chars=len(str(result)),

{drydock_cli-3.0.126 → drydock_cli-3.0.128}/drydock/events.py

@@ -66,3 +66,54 @@ def default_event_log_path():
     import time
     from pathlib import Path
     return Path.home() / ".drydock" / "events" / f"session-{int(time.time())}.jsonl"
+
+
+def _events(events_or_path):
+    return events_or_path if isinstance(events_or_path, list) else EventLog.read(events_or_path)
+
+
+def reconstruct_task_state(events_or_path):
+    """Rebuild a TaskState (objective, acceptance criteria, phase) from an event
+    trace — the PRD "a task can be reconstructed from serialized state" / resume.
+    Returns a fresh TaskState (empty if the trace has no task_start)."""
+    from drydock.task_state import TaskState
+    ts = TaskState()
+    for e in _events(events_or_path):
+        t = e.get("type")
+        if t == "task_start":
+            ts.objective = e.get("objective", "") or ts.objective
+            ts.acceptance_criteria = list(e.get("acceptance_criteria", []) or ts.acceptance_criteria)
+        elif t in ("verify_gate", "verification", "done") and e.get("phase"):
+            ts.phase = e.get("phase", ts.phase)
+        elif t == "verify_gate":
+            ts.phase = "repair" if e.get("kind") == "failed" else "verify"
+        elif t == "done":
+            ts.phase = e.get("phase", ts.phase)
+    return ts
+
+
+def summarize(events_or_path) -> dict:
+    """A compact digest of a task's execution trace for inspection/diagnosis."""
+    evs = _events(events_or_path)
+    tools: dict[str, int] = {}
+    turns = in_tok = out_tok = verify_pass = verify_fail = 0
+    phase = "understand"
+    for e in evs:
+        t = e.get("type")
+        if t == "turn":
+            turns += 1; in_tok += e.get("in_tok", 0) or 0; out_tok += e.get("out_tok", 0) or 0
+        elif t == "tool":
+            tools[e.get("name", "?")] = tools.get(e.get("name", "?"), 0) + 1
+        elif t == "verification":
+            if e.get("status") == "pass": verify_pass += 1
+            elif e.get("status") == "fail": verify_fail += 1
+        elif t == "done":
+            phase = e.get("phase", phase)
+    ts = reconstruct_task_state(evs)
+    return {
+        "objective": ts.objective, "acceptance_criteria": ts.acceptance_criteria,
+        "final_phase": phase, "turns": turns, "tools": tools,
+        "in_tok": in_tok, "out_tok": out_tok,
+        "verifications": {"pass": verify_pass, "fail": verify_fail},
+        "event_count": len(evs),
+    }

{drydock_cli-3.0.126 → drydock_cli-3.0.128}/drydock/tui/app.py

@@ -531,6 +531,8 @@ class DrydockApp(App):
             self._cmd_context(arg)
         elif cmd == "/shell":
             self._cmd_shell()
+        elif cmd == "/events":
+            self._cmd_events()
         elif cmd == "/advisor":
             self._cmd_advisor(arg)
         elif cmd == "/ask":
@@ -837,6 +839,27 @@ class DrydockApp(App):
         else:
             self._begin(prompt)
 
+    def _cmd_events(self) -> None:
+        """Show a digest of this session's durable execution trace (event log)."""
+        log = self.state.events
+        if log is None:
+            self._info("Event log is off (config event_log = false).")
+            return
+        from drydock.events import summarize
+        s = summarize(str(log.path))
+        tools = ", ".join(f"{k}×{v}" for k, v in sorted(s["tools"].items())) or "none"
+        v = s["verifications"]
+        lines = [
+            f"Task trace — {log.path}",
+            f"  objective    : {(s['objective'] or '(none yet)')[:80]}",
+            f"  criteria     : {len(s['acceptance_criteria'])}",
+            f"  phase        : {s['final_phase']}",
+            f"  turns        : {s['turns']}   tools: {tools}",
+            f"  verifications: {v['pass']} passed, {v['fail']} failed",
+            f"  tokens       : {s['in_tok']:,} in / {s['out_tok']:,} out   ({s['event_count']} events)",
+        ]
+        self._info("\n".join(lines))
+
     def _cmd_shell(self) -> None:
         """Show exactly which shell the Bash tool runs commands through, plus the
         platform signals — so a 'still using bash on Windows' report is instantly

{drydock_cli-3.0.126 → drydock_cli-3.0.128}/drydock/tui/widgets.py

@@ -153,7 +153,7 @@ class PromptHistory:
 # completes the prefix.
 SLASH_COMMANDS = [
     "/help", "/model", "/cwd", "/undo", "/back", "/stop", "/status",
-    "/compact", "/context", "/shell", "/advisor", "/ask", "/ask!", "/graphrag", "/skills",
+    "/compact", "/context", "/shell", "/events", "/advisor", "/ask", "/ask!", "/graphrag", "/skills",
     "/loop", "/mcp", "/rmf", "/stig",
     "/clear", "/quit",
 ]

drydock_cli-3.0.128/drydock/verification.py

@@ -0,0 +1,75 @@
+"""Verification gating (Agent-Buildout PRD, Epic B / verification):
+
+  "A text-only model response is not evidence that a task is complete."
+
+The agent loop uses this to decide, when the model claims "done", whether it
+actually VERIFIED — i.e. ran a test, a linter/type-check, a build, or executed the
+code it produced. If it changed files but ran nothing, the loop nudges it to verify
+instead of accepting completion. Deliberately small (a command classifier + the loop
+gate) so it drops into the current loop without a rewrite. Logic original to Drydock.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+# Explicit test / lint / type-check / build commands.
+_VERIFY_KEYWORDS = re.compile(
+    r"\b(pytest|py\.test|unittest|nosetests?|tox|test\.sh|run_tests|"
+    r"make(\s+\w+)?|npm\s+(test|run)|yarn\s+(test|run)|pnpm\s+(test|run)|jest|mocha|vitest|"
+    r"cargo\s+(test|check|build|run|clippy)|go\s+(test|build|run|vet)|"
+    r"ruff|flake8|pylint|mypy|pyright|eslint|tsc|prettier|"
+    r"ctest|cmake|gradle|mvn|rspec|phpunit|dotnet\s+test|bats)\b",
+    re.I,
+)
+# Executing something — running the produced script/binary counts as checking it.
+_EXEC = re.compile(r"(?:^|[\s;&|(])(?:python3?|node|deno|bun|bash|sh|ruby|perl|"
+                   r"java|javac|gcc|g\+\+|clang|\./|\.\\)")
+
+
+def looks_like_verification(cmd) -> bool:
+    """True if a shell command constitutes verifying work — running tests/checks/
+    builds, or executing the produced code. Best-effort; never raises."""
+    if not cmd or not isinstance(cmd, str):
+        return False
+    return bool(_VERIFY_KEYWORDS.search(cmd) or _EXEC.search(cmd))
+
+
+@dataclass
+class VerificationEvidence:
+    """Structured outcome of a verification command — did the check PASS, not just
+    run (PRD verification/evidence). status: 'pass' | 'fail' | 'unknown'."""
+    command: str
+    status: str
+    tests_passed: int | None = None
+    tests_failed: int | None = None
+    exit_code: int | None = None
+    summary: str = ""
+
+
+# tool_bash appends "[exit code: N]" ONLY on non-zero exit; absent => exit 0.
+_EXIT = re.compile(r"\[exit code:\s*(-?\d+)\]")
+# pytest/unittest-style tallies: "3 passed", "2 failed", "1 error".
+_TALLY = re.compile(r"(\d+)\s+(passed|failed|errors?|skipped|xfailed|xpassed)\b", re.I)
+
+
+def parse_evidence(command, result_text) -> VerificationEvidence:
+    """Classify a verification command's result as pass/fail. Exit code is the
+    primary signal (drydock reports non-zero); pytest-style tallies refine it.
+    Best-effort; never raises."""
+    cmd = command if isinstance(command, str) else ""
+    text = result_text if isinstance(result_text, str) else str(result_text or "")
+    m = _EXIT.search(text)
+    exit_code = int(m.group(1)) if m else 0
+    passed = failed = None
+    tally = {}
+    for n, k in _TALLY.findall(text):
+        tally[k.lower().rstrip("s")] = tally.get(k.lower().rstrip("s"), 0) + int(n)
+    if tally:
+        passed = tally.get("passed")
+        failed = tally.get("failed", 0) + tally.get("error", 0)
+    status = "fail" if ((failed and failed > 0) or exit_code != 0) else "pass"
+    parts = [f"exit {exit_code}"]
+    if passed is not None or failed:
+        parts.append(f"{passed or 0} passed, {failed or 0} failed")
+    return VerificationEvidence(cmd, status, passed, failed, exit_code, "; ".join(parts)[:200])

{drydock_cli-3.0.126 → drydock_cli-3.0.128/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.126
+Version: 3.0.128
 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.126 → drydock_cli-3.0.128}/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.126"
+version = "3.0.128"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.11"

{drydock_cli-3.0.126 → drydock_cli-3.0.128}/tests/test_events.py

@@ -56,3 +56,36 @@ def test_run_writes_full_trace():
 def test_disabled_no_events_attr():
     st = agent.AgentState()
     assert st.events is None  # off by default on a bare AgentState
+
+
+def test_reconstruct_task_state_from_trace():
+    from drydock.events import EventLog, reconstruct_task_state
+    p = os.path.join(tempfile.mkdtemp(), "r.jsonl")
+    log = EventLog(p)
+    log.emit("task_start", objective="Recover the password", acceptance_criteria=["23 chars", "write out.txt"])
+    log.emit("tool", name="Write")
+    log.emit("done", phase="complete")
+    ts = reconstruct_task_state(p)
+    assert ts.objective == "Recover the password"
+    assert ts.acceptance_criteria == ["23 chars", "write out.txt"]
+    assert ts.phase == "complete"
+
+
+def test_summarize_digest():
+    from drydock.events import EventLog, summarize
+    p = os.path.join(tempfile.mkdtemp(), "s.jsonl")
+    log = EventLog(p)
+    log.emit("task_start", objective="do X", acceptance_criteria=["a"])
+    log.emit("turn", in_tok=100, out_tok=50)
+    log.emit("tool", name="Bash"); log.emit("tool", name="Bash")
+    log.emit("verification", status="fail"); log.emit("verification", status="pass")
+    log.emit("done", phase="complete")
+    s = summarize(p)
+    assert s["turns"] == 1 and s["tools"] == {"Bash": 2}
+    assert s["verifications"] == {"pass": 1, "fail": 1} and s["final_phase"] == "complete"
+    assert s["in_tok"] == 100 and s["out_tok"] == 50
+
+
+def test_reconstruct_empty_trace():
+    from drydock.events import reconstruct_task_state
+    assert reconstruct_task_state([]).objective == ""

{drydock_cli-3.0.126 → drydock_cli-3.0.128}/tests/test_verification_gate.py

@@ -69,3 +69,35 @@ def test_disabled():
     done = AssistantTurn("done", [], 5, 5)
     st, _ = _drive({**CFG, "verify_gate": False}, [write, done])
     assert not any("VERIFIED" in m.get("content", "") for m in st.messages if m.get("role") == "user")
+
+
+def test_evidence_pass_fail():
+    from drydock.verification import parse_evidence
+    assert parse_evidence("pytest", "5 passed in 0.1s").status == "pass"
+    assert parse_evidence("pytest", "2 failed, 3 passed\n\n[exit code: 1]").status == "fail"
+    assert parse_evidence("python x.py", "boom\n\n[exit code: 1]").status == "fail"
+    ev = parse_evidence("pytest", "2 failed, 3 passed\n\n[exit code: 1]")
+    assert ev.tests_passed == 3 and ev.tests_failed == 2 and ev.exit_code == 1
+
+
+def test_failed_check_triggers_repair_not_complete():
+    # write, then run a FAILING check, then claim done -> gate nudges to REPAIR
+    write = AssistantTurn("", [{"id": "1", "name": "Write",
+                                "input": {"file_path": "/tmp/dd_vg_f.txt", "content": "x"}}], 5, 5)
+    fail = AssistantTurn("", [{"id": "2", "name": "Bash",
+                              "input": {"command": "python -c 'import sys; sys.exit(1)'"}}], 5, 5)
+    done = AssistantTurn("all done", [], 5, 5)
+    st, n = _drive(CFG, [write, fail, done, done])
+    assert st.task.phase == "repair"
+    assert any("FAILED" in m.get("content", "") for m in st.messages if m.get("role") == "user")
+
+
+def test_passing_check_accepts_completion():
+    write = AssistantTurn("", [{"id": "1", "name": "Write",
+                                "input": {"file_path": "/tmp/dd_vg_p.txt", "content": "x"}}], 5, 5)
+    ok = AssistantTurn("", [{"id": "2", "name": "Bash",
+                            "input": {"command": "python -c 'print(1)'"}}], 5, 5)
+    done = AssistantTurn("done, verified", [], 5, 5)
+    st, _ = _drive(CFG, [write, ok, done])
+    assert st.task.phase == "complete"
+    assert not any("FAILED" in m.get("content", "") for m in st.messages if m.get("role") == "user")

drydock_cli-3.0.126/drydock/verification.py

@@ -1,34 +0,0 @@
-"""Verification gating (Agent-Buildout PRD, Epic B / verification):
-
-  "A text-only model response is not evidence that a task is complete."
-
-The agent loop uses this to decide, when the model claims "done", whether it
-actually VERIFIED — i.e. ran a test, a linter/type-check, a build, or executed the
-code it produced. If it changed files but ran nothing, the loop nudges it to verify
-instead of accepting completion. Deliberately small (a command classifier + the loop
-gate) so it drops into the current loop without a rewrite. Logic original to Drydock.
-"""
-from __future__ import annotations
-
-import re
-
-# Explicit test / lint / type-check / build commands.
-_VERIFY_KEYWORDS = re.compile(
-    r"\b(pytest|py\.test|unittest|nosetests?|tox|test\.sh|run_tests|"
-    r"make(\s+\w+)?|npm\s+(test|run)|yarn\s+(test|run)|pnpm\s+(test|run)|jest|mocha|vitest|"
-    r"cargo\s+(test|check|build|run|clippy)|go\s+(test|build|run|vet)|"
-    r"ruff|flake8|pylint|mypy|pyright|eslint|tsc|prettier|"
-    r"ctest|cmake|gradle|mvn|rspec|phpunit|dotnet\s+test|bats)\b",
-    re.I,
-)
-# Executing something — running the produced script/binary counts as checking it.
-_EXEC = re.compile(r"(?:^|[\s;&|(])(?:python3?|node|deno|bun|bash|sh|ruby|perl|"
-                   r"java|javac|gcc|g\+\+|clang|\./|\.\\)")
-
-
-def looks_like_verification(cmd) -> bool:
-    """True if a shell command constitutes verifying work — running tests/checks/
-    builds, or executing the produced code. Best-effort; never raises."""
-    if not cmd or not isinstance(cmd, str):
-        return False
-    return bool(_VERIFY_KEYWORDS.search(cmd) or _EXEC.search(cmd))