drydock-cli 2.8.45__tar.gz → 2.8.46__tar.gz

drydock_cli-2.8.46/.auto_release.lock

@@ -0,0 +1 @@
+2173622

{drydock_cli-2.8.45 → drydock_cli-2.8.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.8.45
+Version: 2.8.46
 Summary: Local-first CLI coding agent — tested with Gemma 4 26B via vLLM
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock

{drydock_cli-2.8.45 → drydock_cli-2.8.46}/drydock/cli/commands.py

@@ -47,6 +47,20 @@ class CommandRegistry:
                 ),
                 handler="_undo_last_turn",
             ),
+            "goal": Command(
+                aliases=frozenset(["/goal"]),
+                description=(
+                    "Set a completion condition and auto-continue across "
+                    "turns until met. Usage:\n"
+                    "  /goal <condition>   — set a goal\n"
+                    "  /goal               — show current goal status\n"
+                    "  /goal clear         — cancel the active goal\n"
+                    "After each turn, a small evaluator checks the "
+                    "condition. If not met, drydock injects a continuation "
+                    "prompt and runs another turn (capped at 20 iterations)."
+                ),
+                handler="_goal_command",
+            ),
             "log": Command(
                 aliases=frozenset(["/log"]),
                 description="Show path to current interaction log file",

{drydock_cli-2.8.45 → drydock_cli-2.8.46}/drydock/cli/textual_ui/app.py

@@ -851,6 +851,21 @@ class DrydockApp(App):  # noqa: PLR0904
                         loading_widget=self._loading_widget,
                     )
 
+            # /goal post-turn hook — if a goal is active, ask the
+            # evaluator whether the condition is met. Met → clear and
+            # tell the user. Not met → queue a continuation prompt so
+            # the next turn fires automatically. The hook only runs on
+            # the success path (skipped on exception below) so a broken
+            # turn doesn't trigger an auto-continuation that re-trips
+            # the same failure.
+            try:
+                await self._check_goal_continuation()
+            except Exception as _goal_e:  # noqa: BLE001
+                import logging
+                logging.getLogger(__name__).warning(
+                    "[goal] post-turn hook failed (skipped): %s", _goal_e,
+                )
+
         except asyncio.CancelledError:
             if self._loading_widget and self._loading_widget.parent:
                 await self._loading_widget.remove()
@@ -2204,6 +2219,143 @@ class DrydockApp(App):  # noqa: PLR0904
                 )
             )
 
+    async def _check_goal_continuation(self) -> None:
+        """Called from `_handle_agent_loop_turn` after the agent's turn
+        finishes. If a goal is active, run the evaluator and either
+        clear (met) or queue a continuation prompt (not met).
+        """
+        loop = self.agent_loop
+        goal = getattr(loop, "goal", None)
+        if goal is None or not goal.active:
+            return
+
+        # Cap check first — never call the evaluator past the cap.
+        if goal.iterations >= goal.max_iterations:
+            await self._mount_and_scroll(UserCommandMessage(
+                f"**Goal hit iteration cap** ({goal.max_iterations}). "
+                f"Stopping auto-continuation for: _{goal.condition}_.\n\n"
+                f"Last verdict: {goal.last_verdict or '(none)'}. "
+                f"Re-issue `/goal <condition>` to restart, or send a "
+                f"normal prompt to continue manually."
+            ))
+            loop.clear_goal()
+            return
+
+        # If the user typed something while we were processing, defer
+        # to their input — don't pre-empt with an auto-continuation.
+        # The queued message will run via _process_queued_message in
+        # the `finally` block below, and the goal will re-evaluate
+        # after THAT turn.
+        if hasattr(self, "_pending_messages") and self._pending_messages:
+            return
+
+        verdict, reasoning = await loop.evaluate_goal()
+        goal.iterations += 1
+
+        if verdict == "YES":
+            await self._mount_and_scroll(UserCommandMessage(
+                f"**Goal met** after {goal.iterations} turn(s): "
+                f"_{goal.condition}_.\n\n"
+                f"Evaluator reasoning: {reasoning or '—'}\n\n"
+                f"Auto-continuation cleared."
+            ))
+            loop.clear_goal()
+            return
+
+        if verdict == "ERROR":
+            # Repeated evaluator errors are not the model's fault and
+            # shouldn't lock the user in. Three errors → stop.
+            err_key = "_goal_eval_error_streak"
+            n = getattr(self, err_key, 0) + 1
+            setattr(self, err_key, n)
+            if n >= 3:
+                await self._mount_and_scroll(UserCommandMessage(
+                    f"**Goal evaluator failing repeatedly** (3 errors in a "
+                    f"row). Last reason: {reasoning}. Clearing the goal — "
+                    f"re-issue `/goal` to retry."
+                ))
+                loop.clear_goal()
+                setattr(self, err_key, 0)
+                return
+            # On a single error, keep the goal but don't auto-continue —
+            # safer than running another turn blind.
+            await self._mount_and_scroll(UserCommandMessage(
+                f"Goal evaluator returned an error: {reasoning}. "
+                f"Pausing auto-continuation for this turn; goal still "
+                f"active. Type any prompt to continue manually."
+            ))
+            return
+
+        # NO — queue a continuation prompt so the next turn fires.
+        setattr(self, "_goal_eval_error_streak", 0)
+        from drydock.core.goal import make_continuation_prompt
+        cont_prompt = make_continuation_prompt(goal)
+        if not hasattr(self, "_pending_messages"):
+            self._pending_messages = []
+        self._pending_messages.append(cont_prompt)
+        await self._mount_and_scroll(UserCommandMessage(
+            f"_Auto-continuing toward goal (turn {goal.iterations}/"
+            f"{goal.max_iterations}): {reasoning or 'not yet met'}_"
+        ))
+
+    async def _goal_command(self, args: str = "") -> None:
+        """/goal — set / show / clear a session-scoped goal that drives
+        automatic turn-after-turn work toward a verifiable condition.
+
+        Usage:
+          /goal <condition>   set a goal (and start auto-continuation)
+          /goal               show the current goal's status
+          /goal clear         cancel the active goal
+        """
+        args = (args or "").strip()
+        loop = self.agent_loop
+
+        # Status (no args) — show whatever goal is active
+        if not args:
+            g = getattr(loop, "goal", None)
+            if g is None or not g.active:
+                await self._mount_and_scroll(UserCommandMessage(
+                    "No active goal. Set one with `/goal <condition>`."
+                ))
+                return
+            verdict = g.last_verdict or "(not yet evaluated)"
+            reason = g.last_evaluator_reasoning or ""
+            await self._mount_and_scroll(UserCommandMessage(
+                f"**Goal:** {g.condition}\n\n"
+                f"- Iterations: {g.iterations} / {g.max_iterations}\n"
+                f"- Last verdict: {verdict}\n"
+                f"- Reasoning: {reason or '—'}\n\n"
+                f"Use `/goal clear` to cancel."
+            ))
+            return
+
+        # Clear
+        if args.lower() in ("clear", "cancel", "stop", "off"):
+            loop.clear_goal()
+            await self._mount_and_scroll(UserCommandMessage(
+                "Goal cleared."
+            ))
+            return
+
+        # Set a new goal
+        # Read DRYDOCK_GOAL_MAX_ITERATIONS for the operator-overridable cap
+        import os
+        try:
+            cap = int(os.environ.get("DRYDOCK_GOAL_MAX_ITERATIONS", "20"))
+            if cap < 1:
+                cap = 20
+        except ValueError:
+            cap = 20
+        loop.set_goal(args, max_iterations=cap)
+        await self._mount_and_scroll(UserCommandMessage(
+            f"**Goal set:** {args}\n\n"
+            f"After each turn, a fast evaluator will check whether the "
+            f"condition holds. If not, drydock will keep working "
+            f"automatically (up to {cap} turns). The goal will clear "
+            f"once met. Use `/goal` to check status, `/goal clear` to "
+            f"cancel."
+        ))
+
     async def _undo_last_turn(self) -> None:
         """Roll back the last user→assistant turn without wiping the
         whole session. Safer alternative to /clear when an error

{drydock_cli-2.8.45 → drydock_cli-2.8.46}/drydock/core/agent_loop.py

@@ -4373,6 +4373,86 @@ or replace freely; future sessions will respect your edits._
     def set_user_input_callback(self, callback: UserInputCallback) -> None:
         self.user_input_callback = callback
 
+    # ------------------------------------------------------------------
+    # Goal pursuit (Claude Code /goal feature) — see drydock/core/goal.py
+    # ------------------------------------------------------------------
+
+    def set_goal(self, condition: str, max_iterations: int = 20) -> None:
+        """Activate goal-pursuit mode. The TUI calls this when the user
+        types `/goal <condition>`. The agent loop itself doesn't act on
+        the goal — the TUI's post-turn hook checks `self.goal` and
+        decides whether to inject a continuation prompt."""
+        from drydock.core.goal import GoalState
+        self.goal = GoalState(
+            condition=condition.strip(),
+            max_iterations=max_iterations,
+        )
+        logger.warning(
+            "[goal] activated: %r (cap=%d turns)",
+            condition[:80], max_iterations,
+        )
+
+    def clear_goal(self) -> None:
+        """Cancel goal-pursuit. Idempotent."""
+        if getattr(self, "goal", None) is not None:
+            logger.warning("[goal] cleared")
+        self.goal = None
+
+    async def evaluate_goal(self) -> tuple[str, str]:
+        """Ask the model whether the active goal has been met.
+
+        Returns (verdict, reasoning) where verdict ∈ {"YES", "NO", "ERROR"}.
+        ERROR means the call itself failed or the response couldn't be
+        parsed — caller should treat as NO and continue (or, after a
+        threshold of ERRORs in a row, clear the goal as a safety hatch).
+        """
+        from drydock.core.goal import (
+            EVALUATOR_SYSTEM_PROMPT,
+            build_evaluator_prompt,
+            collect_recent_message_snippets,
+            parse_verdict,
+        )
+        goal = getattr(self, "goal", None)
+        if goal is None or not goal.active:
+            return ("ERROR", "no active goal")
+
+        snippets = collect_recent_message_snippets(self.messages, n=8)
+        user_prompt = build_evaluator_prompt(goal, snippets)
+
+        eval_messages = [
+            LLMMessage(role=Role.system, content=EVALUATOR_SYSTEM_PROMPT),
+            LLMMessage(role=Role.user, content=user_prompt),
+        ]
+        active_model = self.config.get_active_model()
+        try:
+            # Tight budget — evaluator returns ~30 tokens at most.
+            # Temperature low for determinism. No tools.
+            result = await self.backend.complete(
+                model=active_model,
+                messages=eval_messages,
+                temperature=0.0,
+                tools=[],
+                tool_choice=None,
+                extra_headers=self._get_extra_headers(
+                    self.config.get_active_provider()
+                ),
+                max_tokens=120,
+                metadata=None,
+            )
+        except Exception as e:  # noqa: BLE001 — never crash the TUI on eval error
+            logger.warning("[goal] evaluator call failed: %s", e)
+            return ("ERROR", f"evaluator backend error: {e!s}"[:200])
+
+        raw = (result.message.content or "").strip()
+        verdict, reasoning = parse_verdict(raw)
+        goal.last_verdict = verdict
+        goal.last_evaluator_reasoning = reasoning
+        logger.warning(
+            "[goal] verdict=%s iter=%d/%d reason=%r",
+            verdict, goal.iterations, goal.max_iterations, reasoning[:120],
+        )
+        return (verdict, reasoning)
+
     async def undo_last_turn(self) -> tuple[bool, str]:
         """Rewind history past the LAST user message, dropping the
         assistant turn (and any tool results) it triggered AND the
@@ -4479,6 +4559,10 @@ or replace freely; future sessions will respect your edits._
         self._empty_nudge_last_user_idx = -1
         self._total_error_rounds = 0
         self._read_file_state = {}
+        # /goal state: None means no active goal. Cleared by /clear and
+        # /compact since the goal is session-scoped and a fresh session
+        # shouldn't inherit the prior pursuit.
+        self.goal = None
 
     async def compact(self) -> str:
         try:

drydock_cli-2.8.46/drydock/core/goal.py

@@ -0,0 +1,147 @@
+"""Goal pursuit — autonomous turn-after-turn work toward a condition.
+
+Mirrors the Claude Code `/goal` feature. The user sets a completion
+condition; after every turn, a small evaluator model decides whether
+the condition holds. If not, drydock injects a continuation prompt
+and runs another turn. The goal clears automatically once met.
+
+Design notes:
+  - Iteration cap (default 20) prevents infinite loops on unverifiable
+    or impossible goals.
+  - Evaluator uses the same provider/model as the agent loop. A small
+    dedicated model would be cleaner but complicates local deployment.
+    The evaluator prompt is tight: it returns a single YES/NO token.
+  - The continuation prompt is synthesised — same shape as the existing
+    DRYDOCK_AUTO_CONTINUE mechanism — but tagged with the goal so the
+    main agent loop knows we're on a goal turn, not a user turn.
+  - Status (`/goal` with no args), set (`/goal <condition>`), and
+    clear (`/goal clear`) live in commands.py; this module owns the
+    state, evaluation, and continuation-prompt synthesis.
+"""
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+
+logger = logging.getLogger("drydock.goal")
+
+
+@dataclass
+class GoalState:
+    """Per-session goal state. Owned by the TUI / AgentLoop wrapper."""
+
+    condition: str
+    iterations: int = 0
+    # Conservative cap — covers most realistic workflows (per-turn ~30-80s
+    # on Gemma 4, so 20 turns ~10-25 min) without letting a runaway goal
+    # burn the whole afternoon. Operator can override.
+    max_iterations: int = 20
+    last_verdict: str = ""        # "YES" | "NO" | "ERROR" | "" before first eval
+    last_evaluator_reasoning: str = ""
+
+    @property
+    def active(self) -> bool:
+        return bool(self.condition.strip())
+
+    @property
+    def remaining(self) -> int:
+        return max(0, self.max_iterations - self.iterations)
+
+
+# ── Evaluation prompt ───────────────────────────────────────────────────
+
+EVALUATOR_SYSTEM_PROMPT = (
+    "You are a goal-completion evaluator. You read a goal condition "
+    "plus the recent conversation between a user and a coding agent, "
+    "and you decide whether the goal has been met.\n\n"
+    "Output rules (STRICT):\n"
+    "1. Your FIRST line must be exactly `VERDICT: YES` or `VERDICT: NO`.\n"
+    "2. Your SECOND line should be a one-sentence reason (≤120 chars).\n"
+    "3. Output NOTHING else. No preamble, no markdown, no quotes.\n\n"
+    "Be conservative — only say YES if the conversation contains "
+    "concrete evidence the goal is satisfied. Tool output, test "
+    "results, file contents, or explicit confirmation from the agent. "
+    "Plans, intentions, and 'I will' statements are NOT evidence."
+)
+
+
+def build_evaluator_prompt(goal: GoalState, recent_messages: list[str]) -> str:
+    """Render the evaluator user prompt from the goal + last N msgs."""
+    convo = "\n\n---\n\n".join(recent_messages[-12:])
+    if len(convo) > 8000:
+        convo = convo[:8000] + "\n[... earlier turns truncated]"
+    return (
+        f"GOAL CONDITION:\n{goal.condition}\n\n"
+        f"RECENT CONVERSATION:\n{convo}\n\n"
+        f"Has the goal been met? Respond with VERDICT: YES or VERDICT: NO."
+    )
+
+
+def parse_verdict(raw: str) -> tuple[str, str]:
+    """Parse an evaluator response into (verdict, reasoning).
+
+    verdict ∈ {"YES", "NO", "ERROR"}.
+    """
+    if not raw:
+        return ("ERROR", "evaluator returned empty response")
+    lines = [l.strip() for l in raw.splitlines() if l.strip()]
+    if not lines:
+        return ("ERROR", "evaluator returned only whitespace")
+    first = lines[0].upper()
+    reasoning = lines[1] if len(lines) > 1 else ""
+    # Accept both strict ("VERDICT: YES") and lenient ("YES.") forms
+    if first.startswith("VERDICT:"):
+        verdict_token = first.replace("VERDICT:", "").strip().rstrip(".").strip()
+    else:
+        verdict_token = first.rstrip(".").strip()
+    if verdict_token.startswith("YES"):
+        return ("YES", reasoning)
+    if verdict_token.startswith("NO"):
+        return ("NO", reasoning)
+    return ("ERROR", f"unrecognised verdict token: {first[:60]!r}")
+
+
+def make_continuation_prompt(goal: GoalState) -> str:
+    """The synthesised user message that keeps the agent working.
+
+    Kept short so it doesn't dominate the next turn's context. The
+    main agent loop's system prompt already explains the agent's
+    role; the continuation just refocuses on the goal.
+    """
+    return (
+        f"Continue working toward the goal: {goal.condition}\n"
+        f"(Iteration {goal.iterations}/{goal.max_iterations}. "
+        f"Goal will auto-clear when met.)"
+    )
+
+
+# ── Snippet extraction for the evaluator ────────────────────────────────
+
+def collect_recent_message_snippets(messages, n: int = 8) -> list[str]:
+    """Render the last n messages as short strings the evaluator can
+    read. Truncates each to ≤600 chars so the evaluator prompt stays
+    bounded.
+
+    `messages` is the AgentLoop's `self.messages` — a sequence of
+    LLMMessage objects with .role and .content.
+    """
+    out: list[str] = []
+    # Skip the system message (index 0); take the tail.
+    tail = list(messages)[-n:] if len(messages) > n else list(messages)
+    for m in tail:
+        role = getattr(m, "role", "?")
+        role_str = getattr(role, "value", None) or str(role)
+        content = getattr(m, "content", "") or ""
+        # Include tool-call summaries since they're often the evidence
+        # the evaluator needs (test pass, file written, etc.).
+        tcs = getattr(m, "tool_calls", None) or []
+        if tcs and not content:
+            tc_summary = ", ".join(
+                getattr(getattr(tc, "function", None), "name", "?")
+                for tc in tcs
+            )
+            content = f"[tool calls: {tc_summary}]"
+        if len(content) > 600:
+            content = content[:600] + "...[truncated]"
+        out.append(f"[{role_str}] {content}")
+    return out

{drydock_cli-2.8.45 → drydock_cli-2.8.46}/pyproject.toml

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

drydock_cli-2.8.46/tests/test_goal.py

@@ -0,0 +1,203 @@
+"""Tests for the /goal autonomous-pursuit feature."""
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+import pytest
+
+from drydock.core.goal import (
+    EVALUATOR_SYSTEM_PROMPT,
+    GoalState,
+    build_evaluator_prompt,
+    collect_recent_message_snippets,
+    make_continuation_prompt,
+    parse_verdict,
+)
+
+
+# ── GoalState ───────────────────────────────────────────────────────────
+
+def test_goal_state_defaults():
+    g = GoalState(condition="All tests pass")
+    assert g.active is True
+    assert g.iterations == 0
+    assert g.max_iterations == 20
+    assert g.remaining == 20
+    assert g.last_verdict == ""
+
+
+def test_goal_state_inactive_when_empty():
+    g = GoalState(condition="")
+    assert g.active is False
+    g = GoalState(condition="   ")
+    assert g.active is False
+
+
+def test_goal_state_remaining_decreases():
+    g = GoalState(condition="X", max_iterations=5)
+    g.iterations = 3
+    assert g.remaining == 2
+    g.iterations = 10  # past cap
+    assert g.remaining == 0
+
+
+# ── parse_verdict ───────────────────────────────────────────────────────
+
+@pytest.mark.parametrize("raw,expected_verdict", [
+    ("VERDICT: YES\nAll tests pass.", "YES"),
+    ("VERDICT: NO\nThree tests still failing.", "NO"),
+    ("VERDICT:YES", "YES"),
+    ("verdict: yes\nreason", "YES"),
+    ("YES.", "YES"),
+    ("No.", "NO"),
+    ("yes\n", "YES"),
+])
+def test_parse_verdict_recognises_clear_yes_no(raw, expected_verdict):
+    v, _ = parse_verdict(raw)
+    assert v == expected_verdict
+
+
+def test_parse_verdict_returns_error_for_ambiguous():
+    v, reason = parse_verdict("maybe?")
+    assert v == "ERROR"
+    assert "unrecognised" in reason
+
+
+def test_parse_verdict_empty():
+    v, reason = parse_verdict("")
+    assert v == "ERROR"
+
+
+def test_parse_verdict_extracts_reasoning_from_second_line():
+    v, reason = parse_verdict("VERDICT: NO\nx.py:42 still raises TypeError")
+    assert v == "NO"
+    assert "x.py:42" in reason
+
+
+# ── build_evaluator_prompt + system prompt ──────────────────────────────
+
+def test_evaluator_system_prompt_requires_strict_format():
+    """The system prompt must constrain the evaluator output enough
+    that parse_verdict can read its FIRST line as VERDICT:YES/NO."""
+    assert "VERDICT: YES" in EVALUATOR_SYSTEM_PROMPT
+    assert "VERDICT: NO" in EVALUATOR_SYSTEM_PROMPT
+    assert "FIRST line" in EVALUATOR_SYSTEM_PROMPT
+
+
+def test_build_evaluator_prompt_includes_goal_and_snippets():
+    g = GoalState(condition="x.py:42 returns 0 for empty input")
+    out = build_evaluator_prompt(g, ["[user] write fix", "[assistant] done"])
+    assert "x.py:42 returns 0 for empty input" in out
+    assert "[user]" in out
+    assert "[assistant]" in out
+
+
+def test_build_evaluator_prompt_truncates_long_conversations():
+    g = GoalState(condition="X")
+    huge = ["[user] " + "Z" * 2000] * 10
+    out = build_evaluator_prompt(g, huge)
+    # The function caps total conversation context at 8000 chars
+    assert len(out) < 9000
+
+
+# ── make_continuation_prompt ────────────────────────────────────────────
+
+def test_continuation_prompt_mentions_goal_and_iteration():
+    g = GoalState(condition="All linters pass", max_iterations=10)
+    g.iterations = 4
+    out = make_continuation_prompt(g)
+    assert "All linters pass" in out
+    assert "4/10" in out
+    assert "auto-clear" in out
+
+
+# ── collect_recent_message_snippets ─────────────────────────────────────
+
+class _FakeRole:
+    def __init__(self, v):
+        self.value = v
+
+
+class _FakeMsg:
+    def __init__(self, role, content="", tool_calls=None):
+        self.role = _FakeRole(role)
+        self.content = content
+        self.tool_calls = tool_calls
+
+
+def test_collect_snippets_keeps_last_n_and_truncates_long():
+    msgs = [_FakeMsg("user", f"prompt {i}") for i in range(20)]
+    out = collect_recent_message_snippets(msgs, n=5)
+    assert len(out) == 5
+    assert "prompt 15" in out[0]
+    assert "prompt 19" in out[-1]
+
+
+def test_collect_snippets_summarises_tool_calls_when_content_empty():
+    tc1 = MagicMock()
+    tc1.function.name = "read_file"
+    tc2 = MagicMock()
+    tc2.function.name = "bash"
+    msg = _FakeMsg("assistant", content="", tool_calls=[tc1, tc2])
+    out = collect_recent_message_snippets([msg], n=5)
+    assert len(out) == 1
+    assert "read_file" in out[0]
+    assert "bash" in out[0]
+
+
+def test_collect_snippets_truncates_each_content_to_600():
+    msg = _FakeMsg("assistant", "x" * 2000)
+    out = collect_recent_message_snippets([msg], n=1)
+    assert len(out[0]) < 700  # role tag + 600 chars + truncation marker
+
+
+# ── Command registry ────────────────────────────────────────────────────
+
+def test_goal_command_registered():
+    from drydock.cli.commands import CommandRegistry
+    r = CommandRegistry()
+    cmd = r.commands.get("goal")
+    assert cmd is not None
+    assert "/goal" in cmd.aliases
+    assert cmd.handler == "_goal_command"
+
+
+# ── AgentLoop set_goal / clear_goal / evaluate_goal API ────────────────
+
+def test_agent_loop_exposes_goal_api():
+    from drydock.core.agent_loop import AgentLoop
+    assert callable(getattr(AgentLoop, "set_goal", None))
+    assert callable(getattr(AgentLoop, "clear_goal", None))
+    assert callable(getattr(AgentLoop, "evaluate_goal", None))
+
+
+def test_set_goal_creates_active_state():
+    """Smoke test of set_goal/clear_goal on a stubbed AgentLoop."""
+    from drydock.core.agent_loop import AgentLoop
+    loop = MagicMock(spec=AgentLoop)
+    # bind the real methods
+    loop.set_goal = AgentLoop.set_goal.__get__(loop)
+    loop.clear_goal = AgentLoop.clear_goal.__get__(loop)
+    loop.goal = None
+
+    loop.set_goal("Make tests pass")
+    assert loop.goal is not None
+    assert loop.goal.active
+    assert loop.goal.condition == "Make tests pass"
+    assert loop.goal.max_iterations == 20
+
+    loop.set_goal("Different goal", max_iterations=5)
+    assert loop.goal.condition == "Different goal"
+    assert loop.goal.max_iterations == 5
+
+    loop.clear_goal()
+    assert loop.goal is None
+
+
+def test_clear_goal_is_idempotent():
+    from drydock.core.agent_loop import AgentLoop
+    loop = MagicMock(spec=AgentLoop)
+    loop.clear_goal = AgentLoop.clear_goal.__get__(loop)
+    loop.goal = None
+    loop.clear_goal()  # should not raise
+    assert loop.goal is None

{drydock_cli-2.8.45 → drydock_cli-2.8.46}/trip_log.md

@@ -1,5 +1,18 @@
 # Drydock Trip Log
 
+## 2026-05-16 13:00 UTC tick
+- Stress: paused (.pause_stress sentinel active)
+- Write rate: N/A (stress paused)
+- HLE: 74/603 = 12.3% lifetime; burndown running (PID 2169324, physics batch, 10+ min elapsed)
+- Admiral last 30 min: N/A (stress paused)
+- vLLM 400s: 0 (llamacpp healthy, Q3_K_M + reasoning-budget=12000 + mmproj loaded)
+- GH issues: 0 open (GH #23 closed by 4ef879a mmproj vision feat)
+- Dispatch queue: harness=20 (all thinking_stall false-positives from autonomous_review.log re-classification; already addressed by 23f3530), curiosity=1977 pending
+- Retrieval drain: 0 projects (all already ingested)
+- Curiosity action: consumed 5168c5160c15cdf3 (robot arm timeout — empty prediction, addressed by TOOL_STOP_AFTER + reasoning-budget=12000 existing fixes; 320 hle_failure remain pending)
+- Auto-solve: 120 no_extract events — Z3 hook running but geometry/visual HLE questions don't have extractable formulas (expected)
+- Action this tick: no new fix committed — system healthy
+
 ## 2026-05-16 12:00 UTC tick
 - Stress: paused (.pause_stress sentinel active)
 - Write rate: N/A (stress paused)

drydock_cli-2.8.45/.auto_release.lock

@@ -1 +0,0 @@
-2172060