drydock-cli 3.0.122__tar.gz → 3.0.124__tar.gz

{drydock_cli-3.0.122/drydock_cli.egg-info → drydock_cli-3.0.124}/PKG-INFO

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

@@ -47,6 +47,8 @@ from drydock.compaction import (
     maybe_compact, emergency_compact, is_context_length_error, is_image_load_error,
 )
 from drydock.loop_detect import LoopTracker
+from drydock.task_state import TaskState
+from drydock.verification import looks_like_verification
 from drydock.tuning import (
     filter_tool_schemas,
     hallucinated_tool_message,
@@ -80,6 +82,7 @@ class AgentState:
     last_input_tokens: int = 0  # prompt tokens the SERVER counted on the last call
     turn_count: int = 0
     current_effort: str = ""  # "high"/"low" of the in-flight LLM call (for the UI)
+    task: "TaskState" = field(default_factory=lambda: TaskState())  # structured objective
 
 
 def drop_last_turn(messages: list) -> bool:
@@ -114,6 +117,18 @@ def run(
     """
     state.messages.append({"role": "user", "content": user_message})
 
+    # Capture the structured objective the FIRST time a task arrives, so it lives
+    # outside the transcript. The original objective is authoritative for the task.
+    if not state.task.is_set() and isinstance(user_message, str) and user_message.strip():
+        state.task = TaskState.from_objective(user_message)
+    # Keep the objective + acceptance criteria in the SYSTEM PROMPT every turn, so
+    # they survive compaction (which only touches the message transcript, never the
+    # system prompt) — the model can't drift off the goal on a long task.
+    if config.get("task_anchor", True) and state.task.is_set():
+        anchor = state.task.anchor_text()
+        if anchor:
+            system_prompt = system_prompt + "\n\n" + anchor
+
     # Recipe retrieval: give the model the TECHNIQUE this task needs (forensics,
     # git-history rewrite, numpy-2.0 fix, cert gen, …) by appending the relevant
     # bundled recipes to the system prompt. Keyword-matched, so only fitting ones
@@ -139,6 +154,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
     leaked_call_retries = 0
     plan_continue_nudges = 0  # consecutive "you stopped mid-plan" nudges
     empty_response_nudges = 0  # consecutive "you returned nothing" nudges
@@ -318,6 +335,32 @@ def run(
                     ),
                 })
                 continue
+            # VERIFICATION GATE (PRD Epic B): a text-only "done" is not evidence.
+            # 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 (
+                config.get("verify_gate", True)
+                and session_has_edited
+                and not ran_verification
+                and verify_gate_nudges < 2
+            ):
+                verify_gate_nudges += 1
+                state.task.phase = "verify"
+                state.messages.append({
+                    "role": "user",
+                    "content": (
+                        "[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."
+                    ),
+                })
+                continue
+            if session_has_edited and ran_verification:
+                state.task.phase = "complete"
             break
 
         # Execute each tool call
@@ -325,6 +368,10 @@ 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

{drydock_cli-3.0.122 → drydock_cli-3.0.124}/drydock/config.py

@@ -44,6 +44,14 @@ DEFAULTS: dict[str, object] = {
     # instead of guessing. Retrieval is keyword-overlap; only relevant recipes are
     # added (none = nothing injected). Set false to disable.
     "recipes": True,
+    # Keep the structured objective + acceptance criteria (task_state.py) in the
+    # system prompt every turn so they survive context compaction — the model can't
+    # drift off the original goal on a long task. Set false to disable.
+    "task_anchor": True,
+    # Verification gate (PRD Epic B): if the model claims "done" after changing
+    # files but never ran a test/check/its own code, nudge it to verify first
+    # instead of accepting completion. Bounded. Set false to disable.
+    "verify_gate": True,
     "theme": "harbor",
     # Optional SECOND model ("advisor") for a stronger second opinion — e.g. a
     # Gemini OpenAI-compatible endpoint on another box. Empty = disabled. The

drydock_cli-3.0.124/drydock/task_state.py

@@ -0,0 +1,84 @@
+"""Structured task state — the authoritative objective + acceptance criteria kept
+OUTSIDE the chat transcript, so they survive context compaction and the model never
+loses sight of the goal on a long task.
+
+First increment toward the Agent-Buildout PRD (Epic A: Structured Task State /
+Principle 4.2 "structured state is authoritative"). Deliberately small — a dataclass
+the agent loop populates once and re-injects as a compact anchor after compaction —
+so it drops into the current loop without a rewrite. All logic original to Drydock.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+# Requirement-like lines: numbered (1. / 1)) or bulleted (- * •).
+_LIST_ITEM = re.compile(r"^\s*(?:[-*•]|\d+[.)])\s+(.*\S)\s*$", re.M)
+# Imperative "must/should/exactly/required" sentences (fallback when there's no list).
+_IMPERATIVE = re.compile(r"\b(must|should|exactly|required|ensure|has to|needs? to)\b", re.I)
+
+
+def extract_acceptance_criteria(objective: str, limit: int = 10) -> list[str]:
+    """Pull discrete acceptance criteria out of the objective: numbered/bulleted
+    lines first, else imperative must/should sentences. Best-effort; never raises."""
+    if not objective or not isinstance(objective, str):
+        return []
+    items = [m.group(1).strip() for m in _LIST_ITEM.finditer(objective)]
+    if not items:
+        for s in re.split(r"(?<=[.!?])\s+", objective):
+            s = s.strip()
+            if s and len(s) < 240 and _IMPERATIVE.search(s):
+                items.append(s)
+    # de-dupe preserving order
+    seen: set[str] = set()
+    out = []
+    for it in items:
+        k = it.lower()
+        if k not in seen:
+            seen.add(k)
+            out.append(it)
+    return out[:limit]
+
+
+@dataclass
+class TaskState:
+    """Authoritative task facts, independent of the message transcript."""
+    objective: str = ""
+    acceptance_criteria: list[str] = field(default_factory=list)
+    phase: str = "understand"
+
+    @classmethod
+    def from_objective(cls, objective: str) -> TaskState:
+        obj = (objective or "").strip() if isinstance(objective, str) else str(objective or "").strip()
+        return cls(objective=obj, acceptance_criteria=extract_acceptance_criteria(obj))
+
+    def is_set(self) -> bool:
+        return bool(self.objective)
+
+    def to_dict(self) -> dict:
+        """Serializable WITHOUT the transcript — the task can be reconstructed from this."""
+        return {
+            "objective": self.objective,
+            "acceptance_criteria": list(self.acceptance_criteria),
+            "phase": self.phase,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict) -> TaskState:
+        return cls(
+            objective=d.get("objective", ""),
+            acceptance_criteria=list(d.get("acceptance_criteria", [])),
+            phase=d.get("phase", "understand"),
+        )
+
+    def anchor_text(self) -> str:
+        """A compact, durable reminder re-injected after compaction so a summarized
+        transcript can never lose the original objective + criteria. '' if unset."""
+        if not self.objective:
+            return ""
+        head = self.objective if len(self.objective) <= 700 else self.objective[:700] + " …"
+        lines = [f"[TASK — do not lose sight of the original objective]\n{head}"]
+        if self.acceptance_criteria:
+            lines.append("Acceptance criteria (all must be met):")
+            lines += [f"  - {c}" for c in self.acceptance_criteria]
+        return "\n".join(lines)

drydock_cli-3.0.124/drydock/verification.py

@@ -0,0 +1,34 @@
+"""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))

{drydock_cli-3.0.122 → drydock_cli-3.0.124/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.122
+Version: 3.0.124
 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.122 → drydock_cli-3.0.124}/drydock_cli.egg-info/SOURCES.txt

@@ -26,8 +26,10 @@ drydock/rmf_graph.py
 drydock/skills.py
 drydock/stig.py
 drydock/suggest.py
+drydock/task_state.py
 drydock/tool_registry.py
 drydock/tuning.py
+drydock/verification.py
 drydock/web.py
 drydock/builtin_skills/__init__.py
 drydock/builtin_skills/ml-data.md
@@ -117,6 +119,7 @@ tests/test_streaming_newlines.py
 tests/test_subagent.py
 tests/test_suggest.py
 tests/test_system_prompt_help.py
+tests/test_task_state.py
 tests/test_todo.py
 tests/test_tool_arg_coercion.py
 tests/test_tool_arg_coercion_more.py
@@ -124,6 +127,7 @@ tests/test_tool_arg_parsing.py
 tests/test_tools_undo.py
 tests/test_tui.py
 tests/test_tuning.py
+tests/test_verification_gate.py
 tests/test_viewimage.py
 tests/test_vision_input.py
 tests/test_web_tools.py

{drydock_cli-3.0.122 → drydock_cli-3.0.124}/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.122"
+version = "3.0.124"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.11"

drydock_cli-3.0.124/tests/test_task_state.py

@@ -0,0 +1,69 @@
+"""Structured task state (Agent-Buildout PRD Epic A): the objective + acceptance
+criteria live outside the transcript, are serializable, and survive compaction."""
+from __future__ import annotations
+
+from drydock import agent
+from drydock.providers import AssistantTurn
+from drydock.task_state import TaskState, extract_acceptance_criteria
+
+
+def test_extracts_numbered_and_bulleted_criteria():
+    obj = "Build a parser. Requirements:\n1. Read /app/in.txt\n2. Write /app/out.json\n- Exit 0"
+    c = extract_acceptance_criteria(obj)
+    assert c == ["Read /app/in.txt", "Write /app/out.json", "Exit 0"]
+
+
+def test_extracts_imperative_when_no_list():
+    c = extract_acceptance_criteria("The script must print the CN and it should exit 0.")
+    assert any("must print" in x for x in c)
+
+
+def test_from_objective_and_serializable_without_transcript():
+    ts = TaskState.from_objective("Do X.\n1. A\n2. B")
+    assert ts.is_set() and ts.acceptance_criteria == ["A", "B"] and ts.phase == "understand"
+    d = ts.to_dict()                      # A1.1: serializable without the transcript
+    assert d["objective"] and d["acceptance_criteria"] == ["A", "B"]
+    assert TaskState.from_dict(d).objective == ts.objective   # reconstructable
+
+
+def test_anchor_text_includes_objective_and_criteria():
+    a = TaskState.from_objective("Fix the bug.\n1. tests pass\n2. no regressions").anchor_text()
+    assert "Fix the bug" in a and "tests pass" in a and "no regressions" in a
+    assert TaskState().anchor_text() == ""   # empty when unset
+
+
+def _run_capture(cfg, msg, state=None):
+    seen = {}
+    def fake_stream(model, system, messages, tool_schemas, config):
+        seen["system"] = system
+        yield AssistantTurn("done", [], 5, 5)
+    orig = agent.stream; agent.stream = fake_stream
+    try:
+        st = state or agent.AgentState()
+        list(agent.run(msg, st, cfg, "BASE"))
+        return seen["system"], st
+    finally:
+        agent.stream = orig
+
+
+def test_objective_captured_and_anchored_in_system_prompt():
+    cfg = {"model": "gemma4", "max_tokens": 8192, "context_limit": 65536, "task_anchor": True}
+    sysp, st = _run_capture(cfg, "Recover the password.\n1. it is 23 chars\n2. write it to out.txt")
+    assert st.task.is_set() and st.task.acceptance_criteria == ["it is 23 chars", "write it to out.txt"]
+    assert "TASK" in sysp and "23 chars" in sysp   # anchor present in system prompt
+
+
+def test_anchor_survives_a_compacted_follow_up_turn():
+    # A2: after the transcript is replaced (compaction), the objective is still in the
+    # system prompt on the next turn because it lives in TaskState, not the messages.
+    cfg = {"model": "gemma4", "max_tokens": 8192, "context_limit": 65536, "task_anchor": True}
+    _, st = _run_capture(cfg, "Original objective X.\n1. criterion one")
+    st.messages = [{"role": "user", "content": "(transcript summarized away)"}]  # simulate compaction
+    sysp2, _ = _run_capture(cfg, "keep going", state=st)
+    assert "Original objective X" in sysp2 and "criterion one" in sysp2
+
+
+def test_disabled_when_task_anchor_false():
+    cfg = {"model": "gemma4", "max_tokens": 8192, "context_limit": 65536, "task_anchor": False}
+    sysp, _ = _run_capture(cfg, "Do the thing.\n1. a criterion")
+    assert "TASK" not in sysp

drydock_cli-3.0.124/tests/test_verification_gate.py

@@ -0,0 +1,71 @@
+"""Verification gating (Agent-Buildout PRD Epic B): a text-only 'done' after editing
+files is not accepted until the agent runs a check. Model can't self-declare done."""
+from __future__ import annotations
+
+from drydock import agent
+from drydock.providers import AssistantTurn
+from drydock.verification import looks_like_verification as v
+
+
+def test_classifier():
+    for cmd in ("pytest -q", "python -m pytest tests/", "bash test.sh", "make test",
+                "npm test", "cargo test", "ruff check .", "mypy src", "python solve.py",
+                "./run_check", "node index.js"):
+        assert v(cmd), cmd
+    for cmd in ("ls -la", "cat file.txt", "grep foo bar", "echo hi", "git status", ""):
+        assert not v(cmd), cmd
+    assert not v(None) and not v(123)
+
+
+def _drive(cfg, turns):
+    """turns: list of AssistantTurn to yield in order; returns the messages seen."""
+    calls = {"i": 0}
+    def fake_stream(model, system, messages, tool_schemas, config):
+        i = calls["i"]; calls["i"] += 1
+        yield turns[min(i, len(turns) - 1)]
+    orig = agent.stream; agent.stream = fake_stream
+    try:
+        st = agent.AgentState()
+        list(agent.run("do it", st, cfg, "SYS"))
+        return st, calls["i"]
+    finally:
+        agent.stream = orig
+
+
+CFG = {"model": "gemma4", "max_tokens": 8192, "context_limit": 65536, "verify_gate": True}
+
+
+def test_gate_fires_after_edit_without_verification():
+    # turn 1: Write a file (no tool result needed — execute() runs the real tool);
+    # turn 2: text-only "done". Gate should nudge -> a 3rd call happens.
+    write = AssistantTurn("", [{"id": "1", "name": "Write",
+                                "input": {"file_path": "/tmp/dd_vg.txt", "content": "x"}}], 5, 5)
+    done = AssistantTurn("All done!", [], 5, 5)
+    st, n_calls = _drive(CFG, [write, done, done])
+    # the gate injected a verify nudge → the loop asked the model again (>2 calls)
+    assert n_calls >= 3
+    assert any("VERIFIED" in m.get("content", "") for m in st.messages if m.get("role") == "user")
+
+
+def test_no_gate_when_verification_ran():
+    write = AssistantTurn("", [{"id": "1", "name": "Write",
+                                "input": {"file_path": "/tmp/dd_vg2.txt", "content": "x"}}], 5, 5)
+    check = AssistantTurn("", [{"id": "2", "name": "Bash", "input": {"command": "python -c 'print(1)'"}}], 5, 5)
+    done = AssistantTurn("Done, verified.", [], 5, 5)
+    st, _ = _drive(CFG, [write, check, done])
+    assert not any("VERIFIED" in m.get("content", "") for m in st.messages if m.get("role") == "user")
+    assert st.task.phase == "complete"
+
+
+def test_no_gate_when_no_edits():
+    # pure Q&A: no files changed → nothing to verify → accept immediately
+    st, _ = _drive(CFG, [AssistantTurn("The answer is 42.", [], 5, 5)])
+    assert not any("VERIFIED" in m.get("content", "") for m in st.messages if m.get("role") == "user")
+
+
+def test_disabled():
+    write = AssistantTurn("", [{"id": "1", "name": "Write",
+                                "input": {"file_path": "/tmp/dd_vg3.txt", "content": "x"}}], 5, 5)
+    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")