drydock-cli 2.8.12__tar.gz → 2.8.14__tar.gz

drydock_cli-2.8.14/.auto_release.lock

@@ -0,0 +1 @@
+411933

{drydock_cli-2.8.12 → drydock_cli-2.8.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.8.12
+Version: 2.8.14
 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.12 → drydock_cli-2.8.14}/drydock/admiral/detectors_proposed.py

@@ -58,6 +58,24 @@ def _tool_result_errored(m: LLMMessage) -> bool:
     return any(marker in content for marker in _TOOL_ERROR_MARKERS)
 
 
+def _is_hallucinated_tool_result(m: LLMMessage) -> bool:
+    """A hallucinated-tool result has the format produced by
+    `_silence_suppressed_failures` in agent_loop.py: the content is
+    wrapped in `<tool_error>...</tool_error>` and includes the redirect
+    string "does not exist". When we see this, we know:
+      - the model invented a tool name (ralph_repo_index, exit_plan_mode, ...)
+      - format.py routed it to suppressed_failures + redirect message
+      - drydock injected a system note pointing at real tools
+    The empty turn that follows is a *different* failure mode than
+    empty-after-real-tool — the recovery is already wired and the
+    fire just adds noise to admiral_state.
+    """
+    if m.role is not Role.tool:
+        return False
+    raw = str(getattr(m, "content", "") or "")
+    return "<tool_error>" in raw and "does not exist" in raw
+
+
 def detect_empty_after_tool(
     messages: Sequence[LLMMessage],
 ) -> Optional[Finding]:
@@ -69,6 +87,13 @@ def detect_empty_after_tool(
     "Previous turn ended; awaiting your next instruction." — a user-facing
     sign that the model's thinking channel produced nothing usable.
 
+    Hallucinated-tool results (e.g. `ralph_repo_index`) are EXCLUDED:
+    `_silence_suppressed_failures` already injects a system note redirecting
+    the model to real tools, and the empty turn that follows is a separate
+    failure mode whose recovery is wired elsewhere. Pre-filter, this code
+    fired 318 times against `ralph_repo_index` alone — drowning out the
+    real signal (`empty_after_tool:bash` at 150 fires).
+
     Admiral intervention should:
       (a) inject a directive asking the model to summarize the tool output
           and commit to a next action, and
@@ -91,6 +116,10 @@ def detect_empty_after_tool(
     if prev.role is not Role.tool:
         return None
 
+    # Skip hallucinated-tool results: separate failure mode, separate fix.
+    if _is_hallucinated_tool_result(prev):
+        return None
+
     # Two ways this fires:
     # (1) Live: the assistant returned neither content nor tool_calls. Admiral
     #     sees this BEFORE drydock's _ensure_assistant_after_tools appends

{drydock_cli-2.8.12 → drydock_cli-2.8.14}/drydock/admiral/worker.py

@@ -30,6 +30,12 @@ POLL_INTERVAL_SEC = 5.0
 DEDUP_WINDOW_SEC = 60.0
 MAX_OPUS_PER_SESSION = opus_escalator.MAX_ESCALATIONS_PER_SESSION
 
+# Intervention-outcome window: per persistence.py docstring, "same code
+# re-firing within 10 turns after an intervention = failed." A turn is
+# one assistant message; we count messages (any role) as a proxy because
+# a re-fire necessarily comes after at least 1 assistant turn.
+INTERVENTION_FAIL_WINDOW_TURNS = 10
+
 
 class AdmiralWorker:
     """Async task that supervises one AgentLoop.
@@ -45,6 +51,10 @@ class AdmiralWorker:
         self._recent_findings: dict[str, float] = {}  # code -> timestamp
         self._opus_calls_used: int = 0
         self._in_flight: set[str] = set()  # codes currently being escalated
+        # Pending interventions awaiting outcome classification.
+        # code -> message-count at apply time. On re-fire within
+        # INTERVENTION_FAIL_WINDOW_TURNS messages → failed; otherwise → unstuck.
+        self._pending_interventions: dict[str, int] = {}
 
     def start(self) -> None:
         if self._task is not None and not self._task.done():
@@ -79,8 +89,21 @@ class AdmiralWorker:
             code: ts for code, ts in self._recent_findings.items()
             if now - ts < DEDUP_WINDOW_SEC
         }
+
+        # Resolve any pending interventions whose fail-window has elapsed
+        # without a re-fire — those count as `unstuck=True`.
+        msg_count_now = len(self.agent_loop.messages)
+        self._resolve_elapsed_interventions(msg_count_now)
+
         findings = detectors.run_all(list(self.agent_loop.messages))
         for f in findings:
+            # Re-fire while a prior intervention is still inside its
+            # fail window → that intervention failed.
+            applied_at = self._pending_interventions.get(f.code)
+            if applied_at is not None and (msg_count_now - applied_at) <= INTERVENTION_FAIL_WINDOW_TURNS:
+                self._record_outcome(f.code, unstuck=False)
+                self._pending_interventions.pop(f.code, None)
+
             last = self._recent_findings.get(f.code)
             if last is not None and (now - last) < DEDUP_WINDOW_SEC:
                 continue
@@ -92,6 +115,29 @@ class AdmiralWorker:
                 self._handle_finding(f), name=f"admiral-handle:{f.code[:32]}"
             )
 
+    def _resolve_elapsed_interventions(self, msg_count_now: int) -> None:
+        """Mark interventions as `unstuck=True` if their fail window
+        elapsed without the same code re-firing."""
+        elapsed: list[str] = []
+        for code, applied_at in self._pending_interventions.items():
+            if (msg_count_now - applied_at) > INTERVENTION_FAIL_WINDOW_TURNS:
+                elapsed.append(code)
+        for code in elapsed:
+            self._record_outcome(code, unstuck=True)
+            self._pending_interventions.pop(code, None)
+
+    def _record_outcome(self, code: str, *, unstuck: bool) -> None:
+        """Persist the intervention outcome — never raise (Admiral must
+        not crash drydock). Logs both outcomes to history for visibility."""
+        try:
+            persistence.record_intervention_outcome(code, unstuck=unstuck)
+            history.append(
+                "intervention-outcome",
+                f"{code} :: {'unstuck' if unstuck else 'failed'}",
+            )
+        except Exception as e:
+            logger.debug("record_intervention_outcome failed: %s", e)
+
     async def _handle_finding(self, finding: Finding) -> None:
         """Escalation ladder: local LLM → Opus → canned directive.
 
@@ -101,8 +147,12 @@ class AdmiralWorker:
         proposal in the background.
         """
         try:
-            # Record for Phase 3b promotion criteria.
-            session_id = getattr(self.agent_loop, "_admiral_session_id", "")
+            # Record for Phase 3b promotion criteria. Use the live
+            # `session_id` (matches the on-disk session log dir) so
+            # M5/Deep Noir can extract contrastive pairs from the dir.
+            # Pre-fix this read `_admiral_session_id`, a phantom uuid
+            # that never resolved to anything on disk.
+            session_id = getattr(self.agent_loop, "session_id", "")
             persistence.record_finding(finding.code, session_id)
 
             directive, source = await self._resolve_directive(finding)
@@ -113,6 +163,11 @@ class AdmiralWorker:
             finding_with_text = type(finding)(code=finding.code, directive=directive)
             interventions.apply(self.agent_loop, finding_with_text)
 
+            # Watch for re-fires within the fail window to classify this
+            # intervention's outcome. Without this, prompt_failed stays at
+            # 0 forever and Phase 3b promotion criteria never trigger.
+            self._pending_interventions[finding.code] = len(self.agent_loop.messages)
+
             # Phase 3b: if same finding qualifies and proposer is enabled,
             # kick off a code-proposal draft in the background.
             if persistence.finding_qualifies_for_code_change(finding.code):

{drydock_cli-2.8.12 → drydock_cli-2.8.14}/drydock/core/agent_loop.py

@@ -278,13 +278,16 @@ class AgentLoop:
             logger.debug("Admiral tuning apply failed: %s", _e)
 
         # Admiral Phase 3a: record session metrics on interpreter exit.
+        # Use the live `session_id` (set above and matching the on-disk
+        # session dir) — NOT a fresh uuid. Findings recorded against a
+        # phantom uuid never resolved to a session log, so M5's offline
+        # Deep Noir loop couldn't extract pairs from them.
         try:
-            import atexit, uuid as _uuid
+            import atexit
             from drydock.admiral import metrics as _admiral_metrics
-            self._admiral_session_id = str(_uuid.uuid4())
             atexit.register(
                 lambda al=self: _admiral_metrics.record(
-                    _admiral_metrics.collect(al, al._admiral_session_id, outcome="unknown")
+                    _admiral_metrics.collect(al, al.session_id, outcome="unknown")
                 )
             )
         except Exception as _e:

{drydock_cli-2.8.12 → drydock_cli-2.8.14}/pyproject.toml

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

{drydock_cli-2.8.12 → drydock_cli-2.8.14}/scripts/hle_eval.py

@@ -249,6 +249,35 @@ def _question_prompt(q: dict) -> str:
     )
 
 
+def _send_prompt_as_paste(child, text: str) -> None:
+    """Send a one-shot prompt to the TUI as a bracketed paste, then Enter.
+
+    Why not `sk.type_message`: it sends char-by-char at 10ms/char, which
+    on a ~1500-char HLE prompt takes ~15s and races the Textual input
+    handler. In real captured sessions we observed 13 stray `\\n` chars
+    injected mid-word (`'Answer th\\n\\n...\\n\\nis question'`) — the
+    model then reads garbage and either bails or grinds in tool-call
+    loops without ever emitting `FINAL ANSWER:`. Bracketed paste
+    (xterm convention also recognised by Textual >=0.40) tells the
+    receiving widget "this is a single literal block — do not interpret
+    embedded chars as keypresses or trigger paste-detection logic."
+
+    Sequence:
+      ESC [ 2 0 0 ~  <text-with-newlines-stripped>  ESC [ 2 0 1 ~  <Enter>
+
+    Newlines inside the prompt are stripped because Textual's Input
+    widget commits on Enter regardless of paste markers. HLE prompts
+    are a single line by construction (`_question_prompt`), so this is
+    a no-op for the supported case.
+    """
+    safe_text = text.replace("\r", " ").replace("\n", " ")
+    PASTE_START = "\x1b[200~"
+    PASTE_END = "\x1b[201~"
+    child.send(PASTE_START + safe_text + PASTE_END)
+    time.sleep(0.3)  # let the widget commit the paste
+    child.send("\r")
+
+
 def _extract_answer(messages: list[dict]) -> str:
     """Pull the FINAL ANSWER line out of the last assistant message that
     has text content. Falls back to the full last assistant content if no
@@ -306,7 +335,7 @@ def run_one(q: dict, sk, run_dir: Path) -> dict:
         pass
 
     watcher = sk.SessionWatcher(cwd, since=start)
-    sk.type_message(child, _question_prompt(q))
+    _send_prompt_as_paste(child, _question_prompt(q))
     time.sleep(1)
 
     # Wait for session dir to appear

drydock_cli-2.8.14/tests/test_admiral_hallucinated_tool_filter.py

@@ -0,0 +1,89 @@
+"""Regression: detect_empty_after_tool must skip hallucinated-tool results.
+
+Pre-filter, `empty_after_tool:ralph_repo_index` was the highest-fire
+finding in admiral_state (318 fires, 164 sessions) — out-volume-ing
+real signals like `empty_after_tool:bash` (150 fires, 85 sessions).
+
+The hallucinated-tool path already has its own recovery wired
+(`_silence_suppressed_failures` in agent_loop.py injects a system note
+that redirects the model to real tools). The empty turn that follows
+is a *different* failure mode and conflating it with real-tool empty
+stalls confused both admiral analytics and the Phase 3b proposer.
+"""
+from __future__ import annotations
+
+from drydock.admiral.detectors_proposed import detect_empty_after_tool
+from drydock.core.types import LLMMessage, Role
+
+
+def _user(text: str) -> LLMMessage:
+    return LLMMessage(role=Role.user, content=text)
+
+
+def _assistant_empty() -> LLMMessage:
+    return LLMMessage(role=Role.assistant, content="", tool_calls=[])
+
+
+def _tool_result(name: str, content: str) -> LLMMessage:
+    m = LLMMessage(role=Role.tool, content=content)
+    m.name = name  # detect_empty_after_tool reads getattr(prev, "name", "")
+    return m
+
+
+def test_empty_after_real_tool_still_fires() -> None:
+    """The detector must still fire on legitimate empty-after-real-tool stalls."""
+    msgs = [
+        _user("read the config"),
+        _tool_result("read_file", "the contents of config.toml"),
+        _assistant_empty(),
+    ]
+    f = detect_empty_after_tool(msgs)
+    assert f is not None
+    assert f.code == "empty_after_tool:read_file"
+
+
+def test_empty_after_hallucinated_tool_is_filtered() -> None:
+    """`<tool_error>...does not exist...</tool_error>` content marks a
+    hallucinated-tool result. Empty turn after it must NOT fire — the
+    system-note recovery handles this case."""
+    halluc_content = (
+        "<tool_error>ralph_repo_index: 'ralph_repo_index' does not exist "
+        "— do not call it again. To list project files: call glob...</tool_error>"
+    )
+    msgs = [
+        _user("explore the repo"),
+        _tool_result("ralph_repo_index", halluc_content),
+        _assistant_empty(),
+    ]
+    f = detect_empty_after_tool(msgs)
+    assert f is None, (
+        f"Hallucinated-tool empty turn should NOT fire; got {f.code if f else None}"
+    )
+
+
+def test_empty_after_other_hallucinated_names_filtered() -> None:
+    """Same filter applies regardless of hallucinated tool name (
+    exit_plan_mode, lsp, etc.)."""
+    for name in ("exit_plan_mode", "lsp", "ralph_file_summary", "list_mcp_resources"):
+        content = f"<tool_error>{name}: '{name}' does not exist — stop calling it.</tool_error>"
+        msgs = [
+            _user("go"),
+            _tool_result(name, content),
+            _assistant_empty(),
+        ]
+        f = detect_empty_after_tool(msgs)
+        assert f is None, f"Should be filtered for hallucinated tool {name!r}; got {f.code if f else None}"
+
+
+def test_real_tool_with_error_still_fires() -> None:
+    """A real tool that errored normally (not via hallucination suppression)
+    should still fire — the marker is the specific
+    `<tool_error>...does not exist` shape, not just any error."""
+    msgs = [
+        _user("read it"),
+        _tool_result("read_file", "Error: file not found at /tmp/missing.py"),
+        _assistant_empty(),
+    ]
+    f = detect_empty_after_tool(msgs)
+    assert f is not None
+    assert f.code == "empty_after_tool:read_file"

drydock_cli-2.8.14/tests/test_admiral_intervention_outcome.py

@@ -0,0 +1,155 @@
+"""Regression: AdmiralWorker must classify each intervention's outcome
+(unstuck vs. failed) and persist it via `record_intervention_outcome`.
+
+Pre-fix, `record_intervention_outcome` was defined in persistence.py
+and unit-tested but had ZERO production call sites. Result:
+`prompt_failed` stayed at 0 forever, so
+`finding_qualifies_for_code_change` (which requires prompt_failed >= 1)
+never returned True. The whole Phase 3b proposer pipeline was silently
+dormant — 1010 admiral findings accumulated, 0 ever qualified.
+
+Post-fix, the worker tracks `_pending_interventions[code] = msg_count`
+at apply time. On _tick:
+- If the same code re-fires within INTERVENTION_FAIL_WINDOW_TURNS
+  messages → record `unstuck=False`
+- If the window elapses without a re-fire → record `unstuck=True`
+"""
+from __future__ import annotations
+
+import asyncio
+import inspect
+from dataclasses import dataclass, field
+from typing import Any
+
+import pytest
+
+from drydock.admiral import history, interventions, persistence, worker
+from drydock.admiral.detectors import Finding
+
+
+@dataclass
+class _StubAgentLoop:
+    session_id: str = "sess-test"
+    # Mutable list so tests can grow it to simulate turns passing.
+    messages: list = field(default_factory=list)
+
+
+@pytest.fixture
+def patched_world(monkeypatch):
+    """Stub out persistence + history so we can observe outcome calls
+    without touching disk."""
+    captured = {"outcomes": [], "findings": []}
+
+    monkeypatch.setattr(
+        persistence, "record_finding",
+        lambda code, sid: captured["findings"].append((code, sid)) or {
+            "sessions": [sid], "total_fires": 1, "last_seen": "now"
+        },
+    )
+    monkeypatch.setattr(
+        persistence, "record_intervention_outcome",
+        lambda code, unstuck: captured["outcomes"].append((code, unstuck)),
+    )
+    monkeypatch.setattr(
+        persistence, "finding_qualifies_for_code_change",
+        lambda code, **kw: False,
+    )
+
+    async def _stub_resolve(self, finding):
+        return finding.directive, "canned"
+
+    monkeypatch.setattr(worker.AdmiralWorker, "_resolve_directive", _stub_resolve)
+    monkeypatch.setattr(history, "append", lambda *a, **kw: None)
+    monkeypatch.setattr(interventions, "apply", lambda agent, finding: None)
+    return captured
+
+
+def _drain_pending(w: worker.AdmiralWorker):
+    """Trigger any awaited tasks in the running loop."""
+    pass  # asyncio.run handles this for us
+
+
+def test_intervention_marked_failed_on_refire(patched_world):
+    """Re-fire within the fail window → record outcome unstuck=False."""
+    al = _StubAgentLoop(messages=[1, 2, 3, 4, 5])  # 5 messages at apply
+    w = worker.AdmiralWorker(al)
+
+    # Apply intervention via the public path
+    finding = Finding(code="loop:read_file", directive="stop")
+    asyncio.run(w._handle_finding(finding))
+
+    # Worker recorded the apply-time message count
+    assert w._pending_interventions == {"loop:read_file": 5}
+
+    # Simulate 3 more messages, then the same finding fires again via _tick.
+    al.messages.extend([6, 7, 8])
+
+    # Patch detectors to return our re-fire and stub create_task (the
+    # outcome-record path runs inline in _tick, before create_task).
+    import drydock.admiral.worker as wmod
+    original_run_all = wmod.detectors.run_all
+    original_create = wmod.asyncio.create_task
+    wmod.detectors.run_all = lambda msgs: [Finding(code="loop:read_file", directive="stop")]
+    wmod.asyncio.create_task = lambda coro, **kw: coro.close() or None
+    try:
+        # Bypass dedup so the re-fire is observed
+        w._recent_findings.clear()
+        w._tick()
+    finally:
+        wmod.detectors.run_all = original_run_all
+        wmod.asyncio.create_task = original_create
+
+    assert ("loop:read_file", False) in patched_world["outcomes"], (
+        "Expected `unstuck=False` outcome on re-fire within window"
+    )
+    # Pending entry must be cleared so we don't double-record
+    assert "loop:read_file" not in w._pending_interventions
+
+
+def test_intervention_marked_unstuck_when_window_elapses(patched_world):
+    """No re-fire within window → record outcome unstuck=True."""
+    al = _StubAgentLoop(messages=list(range(5)))
+    w = worker.AdmiralWorker(al)
+
+    finding = Finding(code="empty_after_tool:bash", directive="continue")
+    asyncio.run(w._handle_finding(finding))
+    assert "empty_after_tool:bash" in w._pending_interventions
+
+    # Push past the fail window (10 turns) without any re-fires
+    al.messages.extend(list(range(20)))  # 25 total, delta 20 > 10
+
+    import drydock.admiral.worker as wmod
+    original = wmod.detectors.run_all
+    wmod.detectors.run_all = lambda msgs: []  # no findings this tick
+    try:
+        w._tick()
+    finally:
+        wmod.detectors.run_all = original
+
+    assert ("empty_after_tool:bash", True) in patched_world["outcomes"], (
+        "Expected `unstuck=True` outcome after window elapsed without re-fire"
+    )
+    assert "empty_after_tool:bash" not in w._pending_interventions
+
+
+def test_intervention_outcome_persistence_swallows_errors(patched_world, monkeypatch):
+    """Persistence failure must NOT crash Admiral (rule: Admiral never
+    takes drydock down)."""
+    def boom(code, unstuck):
+        raise RuntimeError("disk full")
+    monkeypatch.setattr(persistence, "record_intervention_outcome", boom)
+
+    w = worker.AdmiralWorker(_StubAgentLoop())
+    # Should not raise
+    w._record_outcome("loop:foo", unstuck=True)
+
+
+def test_record_intervention_outcome_has_production_callsite():
+    """Belt-and-suspenders: catch a future revert that would re-orphan
+    this function. Only worker.py + tests should reference it."""
+    src = inspect.getsource(worker)
+    assert "record_intervention_outcome" in src, (
+        "AdmiralWorker no longer wires intervention outcomes to "
+        "persistence — Phase 3b promotion criteria will be dormant. "
+        "See worker._record_outcome / _resolve_elapsed_interventions."
+    )

drydock_cli-2.8.14/tests/test_admiral_session_id.py

@@ -0,0 +1,95 @@
+"""Regression: Admiral must record findings against the live
+`AgentLoop.session_id` (which matches the on-disk session log dir),
+NOT a fresh phantom uuid.
+
+Pre-fix, agent_loop.py:284 set `self._admiral_session_id = uuid4()`
+and worker.py:105 read that attribute. The result was 1010 admiral
+findings keyed to UUIDs that never resolved to any session dir under
+~/.drydock/logs/session/, breaking M5/Deep Noir's pair extraction.
+"""
+from __future__ import annotations
+
+import asyncio
+import inspect
+from dataclasses import dataclass
+from typing import Any
+
+import pytest
+
+from drydock.admiral import history, interventions, llm_analyzer, persistence, worker
+from drydock.admiral.detectors import Finding
+
+
+@dataclass
+class _StubAgentLoop:
+    """Minimal stand-in for AgentLoop — only the attrs the worker reads."""
+    session_id: str = "real-session-abc-123"
+    messages: tuple = ()
+
+
+def test_worker_records_finding_with_live_session_id(monkeypatch):
+    """When _handle_finding fires, persistence.record_finding must
+    receive the agent_loop's `session_id` — not a fresh uuid, not "".
+    """
+    captured: list[tuple[str, str]] = []
+
+    monkeypatch.setattr(
+        persistence, "record_finding",
+        lambda code, sid: captured.append((code, sid)) or {
+            "sessions": [sid], "total_fires": 1, "last_seen": "now"
+        },
+    )
+    monkeypatch.setattr(
+        persistence, "finding_qualifies_for_code_change",
+        lambda code, **kw: False,
+    )
+
+    async def _stub_resolve(self, finding):
+        return finding.directive, "canned"
+
+    monkeypatch.setattr(worker.AdmiralWorker, "_resolve_directive", _stub_resolve)
+    monkeypatch.setattr(history, "append", lambda *a, **kw: None)
+    monkeypatch.setattr(interventions, "apply", lambda agent, finding: None)
+
+    al = _StubAgentLoop(session_id="known-real-session-xyz")
+    w = worker.AdmiralWorker(al)
+    finding = Finding(code="loop:read_file", directive="stop reading")
+
+    asyncio.run(w._handle_finding(finding))
+
+    assert captured == [("loop:read_file", "known-real-session-xyz")], (
+        "Admiral recorded finding against wrong session id — pair extraction "
+        "will fail. See agent_loop.py:280 + worker.py:105."
+    )
+
+
+def test_worker_source_does_not_reference_phantom_uuid_attr():
+    """Belt-and-suspenders: the source must read `session_id`, not the
+    pre-fix `_admiral_session_id` attribute. Catches accidental reverts."""
+    src = inspect.getsource(worker.AdmiralWorker._handle_finding)
+    assert "_admiral_session_id" not in src or src.find("_admiral_session_id") > src.find("Pre-fix"), (
+        "_handle_finding still reads `_admiral_session_id` outside of a "
+        "comment. Use `agent_loop.session_id` so M5 can resolve sessions "
+        "to on-disk dirs."
+    )
+    assert "agent_loop, \"session_id\"" in src or "agent_loop, 'session_id'" in src, (
+        "_handle_finding must read `session_id` from the live agent_loop."
+    )
+
+
+def test_agent_loop_does_not_set_phantom_uuid_attr():
+    """The AgentLoop init must NOT create a separate `_admiral_session_id`
+    attribute that diverges from `session_id`."""
+    from drydock.core import agent_loop as agent_loop_mod
+    src = inspect.getsource(agent_loop_mod)
+    # The attribute may appear in a comment explaining the fix; it must
+    # not appear as an assignment outside a comment.
+    for line in src.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("#"):
+            continue
+        assert "self._admiral_session_id" not in stripped, (
+            "agent_loop.py still assigns `self._admiral_session_id` — "
+            "this UUID never resolves to an on-disk session dir. Use "
+            "`self.session_id` directly."
+        )

drydock_cli-2.8.14/tests/test_hle_typing.py

@@ -0,0 +1,90 @@
+"""Regression: HLE prompts must reach the TUI as a single literal block.
+
+Prior to the fix, `sk.type_message` typed char-by-char at 10ms/char,
+racing Textual's input handler. In real captured sessions
+(/home/bobef/.vibe/logs/session/session_20260509_015004_1fa9ac60),
+the prompt `"Answer this question..."` arrived as
+`"Answer th\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nis question..."`
+— 13 stray newlines injected mid-word. The model then grinds in
+tool-call loops and never emits `FINAL ANSWER:`, so 20/20 of the
+phase1_steered run had empty predictions.
+
+Post-fix, `_send_prompt_as_paste` wraps the prompt in xterm bracketed-
+paste markers and writes once. The Textual Input widget treats the
+contents as a literal block — no paste-detection, no per-char races.
+"""
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parent.parent
+HLE_EVAL = REPO / "scripts" / "hle_eval.py"
+
+
+def _load_hle_eval():
+    spec = importlib.util.spec_from_file_location("hle_eval_under_test", HLE_EVAL)
+    mod = importlib.util.module_from_spec(spec)
+    # Skip optional sk import dance — we only need _send_prompt_as_paste.
+    sys.modules["hle_eval_under_test"] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+class _CaptureChild:
+    """Minimal pexpect.spawn stand-in: records every send() call."""
+    def __init__(self):
+        self.sent: list[str] = []
+    def send(self, text: str) -> None:
+        self.sent.append(text)
+
+
+def test_send_prompt_as_paste_uses_bracketed_paste_markers():
+    he = _load_hle_eval()
+    child = _CaptureChild()
+    prompt = "Answer this question. End your response with 'FINAL ANSWER:' followed by your answer on the same line. QUESTION: What is 2+2?"
+
+    he._send_prompt_as_paste(child, prompt)
+
+    # Two sends: paste-block, then Enter
+    assert len(child.sent) == 2, f"expected 2 sends, got {len(child.sent)}: {child.sent!r}"
+    assert child.sent[0].startswith("\x1b[200~"), "paste must open with ESC[200~"
+    assert child.sent[0].endswith("\x1b[201~"), "paste must close with ESC[201~"
+    assert child.sent[1] == "\r", "second send must be Enter"
+
+    # The literal prompt must appear inside the paste block, intact and
+    # contiguous — no whitespace or newlines injected mid-word.
+    payload = child.sent[0][len("\x1b[200~"):-len("\x1b[201~")]
+    assert payload == prompt, (
+        f"prompt was mangled inside paste markers:\n"
+        f"  expected: {prompt!r}\n"
+        f"  got:      {payload!r}"
+    )
+
+
+def test_send_prompt_strips_embedded_newlines():
+    """Textual Input commits on Enter regardless of paste markers, so
+    embedded newlines would still split the message. Strip them before
+    sending — HLE prompts are single-line by `_question_prompt`'s contract."""
+    he = _load_hle_eval()
+    child = _CaptureChild()
+    he._send_prompt_as_paste(child, "line one\nline two\rline three")
+    payload = child.sent[0][len("\x1b[200~"):-len("\x1b[201~")]
+    assert "\n" not in payload, f"newline leaked through: {payload!r}"
+    assert "\r" not in payload, f"carriage return leaked through: {payload!r}"
+    assert payload == "line one line two line three"
+
+
+def test_send_prompt_does_not_use_per_char_typing():
+    """Per-char typing is the bug — verify exactly two send() calls
+    (paste-block, Enter), not one per character. A long prompt would
+    produce 1000+ sends in the broken path."""
+    he = _load_hle_eval()
+    child = _CaptureChild()
+    long_prompt = "x" * 2000
+    he._send_prompt_as_paste(child, long_prompt)
+    assert len(child.sent) == 2, (
+        f"per-char typing has regressed; got {len(child.sent)} sends "
+        f"for a 2000-char prompt"
+    )