drydock-cli 2.6.136__tar.gz → 2.6.138__tar.gz

drydock_cli-2.6.138/Admiral.md

@@ -0,0 +1,186 @@
+# PRD: Admiral + Drydock (Adaptive Agent Orchestration System)
+
+## 1. Overview
+* **Execution Harness:** Drydock
+* **Orchestration & Meta-Learning Layer:** Admiral
+* **Vision:** Create an observable, self-tuning LLM harness. Drydock handles the deterministic execution of agentic tasks (tools, loops, file ops), while Admiral operates as an out-of-band supervisor that detects failure patterns, dynamically updates execution parameters, and controls the system's learning rate to prevent behavioral degradation.
+
+## 2. Core Problem
+Current agent harnesses suffer from architectural fragility:
+* **Static Execution:** They rely on hardcoded routing logic and brittle system prompts.
+* **Zero Self-Awareness:** They cannot detect when they are stuck in a logical loop or hallucinating tool calls.
+* **Lack of Domain Adaptation:** A coding agent and a research agent require different tolerances for loops and errors, but standard harnesses treat them identically.
+* **The Root Issue:** We are deploying non-deterministic intelligence inside rigid, deterministic boxes. 
+
+## 3. System Architecture
+The system utilizes a dual-layer approach, strictly separating the "doing" from the "supervising."
+
+```text
+[ User Interface (TUI / CLI) ]
+            |
+            v
+[ ADMIRAL (Meta-Controller) ] <--- Telemetry & Logs
+            |                      |
+      State Config                 |
+            v                      |
+[ DRYDOCK (Execution Engine) ] ----+
+            |
+    [ LLM Kernel ] <--> [ Tool / Env Runtime ]
+```
+
+## 4. Core Components
+
+### 4.1 Admiral (The Orchestrator)
+Admiral does not execute tasks. It ingests telemetry, evaluates execution health, and pushes state updates to Drydock.
+
+* **A. Telemetry Ingestion:** Processes structured logs from Drydock (token usage, tool call frequency, error stack traces, execution latency).
+* **B. Pattern & Anomaly Detection:**
+    * *Loop Detection:* Identifies repeated sequential tool calls with identical outputs.
+    * *Struggle Detection:* Identifies high token burn with zero file modifications or task progression.
+* **C. State-Driven Modification (Not Code-Rewriting):**
+    * Admiral modifies Drydock's behavior by updating its **State Config** (e.g., system prompt matrices, tool-access blocklists, max-loop constraints). It does *not* rewrite source code.
+* **D. Learning Rate Scheduler:**
+    * Controls how fast Admiral can alter Drydock's baseline configuration.
+    * *Cold Start:* High tolerance for manual interventions, low threshold for prompt tweaks.
+    * *Stable:* High threshold for baseline changes; relies on localized session memory.
+* **E. Interventions & Versioning:**
+    * Pauses Drydock when a failure threshold is crossed.
+    * Prompts the user via TUI: *"Loop detected. Propose dropping [WebSearch] tool and appending directive: 'Use grep instead'. Approve? (Y/N)"*
+    * Maintains a Git-like history of all config state changes for instant rollbacks.
+
+### 4.2 Drydock (The Execution Harness)
+Drydock is a highly modular, state-driven execution loop. 
+
+* **A. State-Hydrated Execution:** Drydock boots up by reading the config injected by Admiral. If Admiral alters the system prompt or revokes a tool mid-flight, Drydock adopts the new state on the next loop iteration.
+* **B. Modular Primitives:**
+    * *Planner:* Maps the initial task.
+    * *Executor:* Formats the prompt and parses the LLM output.
+    * *Tool Router:* Safely executes the requested local commands.
+* **C. Telemetry Emitter:** Emits a standardized JSON log for every step (e.g., `{"step": 4, "action": "tool_call", "tool": "bash", "status": "error", "latency": "1.2s"}`) directly to Admiral.
+
+## 5. Example Execution Flow (Stuck State Mitigation)
+1.  **Drydock:** Attempts to run a broken Python script 4 times. Each time, the LLM hallucinates the same incorrect fix.
+2.  **Drydock:** Emits 4 identical error logs to the telemetry stream.
+3.  **Admiral:** Detects the pattern. The confidence score for a "Logic Loop" hits 0.95.
+4.  **Admiral:** Issues a `PAUSE` signal to Drydock. 
+5.  **Admiral (via TUI):** *"Drydock is looping on a syntax error. Suggestion: Inject context directive 'Stop attempting to fix lines 40-50, rewrite the function from scratch.' Apply? (Y/n)"*
+6.  **User:** Hits 'Y'.
+7.  **Admiral:** Updates Drydock's temporary session config with the new directive. Issues `RESUME`.
+8.  **Drydock:** Re-evaluates the prompt with the new directive and breaks the loop.
+
+## 6. Project Risks & Mitigations
+* **Risk:** The system becomes too complex to debug (who broke it, Admiral or the LLM?).
+    * *Mitigation:* Strict, readable audit logs. Every change Admiral makes to Drydock's state must be written to a plain-text `admiral_history.log`.
+* **Risk:** Overfitting to specific user quirks.
+    * *Mitigation:* Separate the memory stores. Maintain a `Session State` (wiped every run) and a `Global State` (persistent). Admiral must prove a fix works across multiple sessions before committing it to the Global State.
+* **Risk:** "Hallucinated" fixes by Admiral.
+    * *Mitigation:* Admiral uses hardcoded heuristic triggers for Phase 1 MVP, *not* an LLM, to decide when to intervene. 
+
+## 7. MVP Scope (Phase 1)
+* **Drydock:** Basic CLI/TUI that can execute shell commands, read/write files, and query an LLM. Must emit structured JSON logs.
+* **Admiral:** A background Python thread that tails Drydock's logs.
+* **Features:**
+    * Regex-based loop detection.
+    * Hard pause capability.
+    * Ability to let the user manually inject a new system prompt directive mid-run without restarting the context window.
+
+***
+
+## 8. Implementation Status (2026-04-17)
+
+### Phase 1 — SHIPPED (module present in v2.6.137, wiring in flight for v2.6.138)
+
+Architecture: **in-process** (option C). Admiral runs as an asyncio.Task
+inside the Textual app's event loop — same process as the agent, no IPC.
+Auto-apply default (no Y/N approval) per user directive.
+
+Files:
+* `drydock/admiral/__init__.py` — public API (`attach(agent_loop)`).
+* `drydock/admiral/detectors.py` — `detect_tool_call_loop`,
+  `detect_struggle`, `run_all`. Pure functions; return `Finding(code, directive)`.
+* `drydock/admiral/interventions.py` — `apply(agent_loop, finding)` →
+  calls `AgentLoop._inject_system_note` + appends to audit log.
+* `drydock/admiral/history.py` — append-only timestamped log at
+  `~/.vibe/logs/admiral_history.log`.
+* `drydock/admiral/worker.py` — `AdmiralWorker` async task that polls
+  every 5s, dedup window 60s per finding code.
+* `tests/test_admiral.py` — 5 tests for detector correctness.
+
+Integration:
+* `drydock/cli/textual_ui/app.py::on_mount` — `admiral.attach(agent_loop)`
+  after approval callbacks are set. Stored on `self._admiral`. Any Admiral
+  import/startup error is logged but never prevents the TUI from starting.
+
+Detectors (Phase 1):
+1. **Loop detection** — 3+ identical (tool_name + arguments) calls in a
+   row → inject directive telling the model to stop the loop.
+2. **Struggle detection** — 20+ non-write tool calls since the last
+   `write_file`/`search_replace`/`edit_file` → inject "write code or
+   tell the user you're stuck."
+
+### Phase 2 — DESIGNED (target v2.6.139+)
+
+Escalation ladder for when heuristics aren't enough:
+
+```
+[Admiral detector fires]
+        |
+        v
+[local Gemma 4 meta-analysis] — send the last N turns + the finding to
+                                the local vLLM endpoint asking "what
+                                is really going wrong? what directive
+                                would unstick the agent?"
+        |
+        v (low confidence / model also stumped)
+[Claude Code (Opus) escalation] — shell out to `claude -p "<analysis>"`
+                                   (or the Anthropic SDK) for a second
+                                   opinion. Cap at N escalations per
+                                   session.
+        |
+        v
+[Admiral applies Opus's directive via _inject_system_note]
+```
+
+Open design questions for Phase 2:
+* Local LLM reuse: should Admiral reuse the agent's own backend
+  connection, or open its own at a different temperature?
+  → **Lean:** reuse `AgentLoop.backend` with a separate message list
+  and lower temperature (0.1 vs 0.7) so the analysis is deterministic.
+* Opus access: `claude -p` CLI or `anthropic` SDK?
+  → **Lean:** SDK when `ANTHROPIC_API_KEY` is set; fall back to
+  `claude -p` when not (so users who already have Claude Code auth
+  don't need to re-enter a key).
+* Rate-limiting: prevent Opus blast during a bad run. Max 3 escalations
+  per session by default. Override via env var.
+
+### Phase 3 — IDEAS (not started)
+
+* **Learning-rate scheduler (PRD §4.1.D)** — cold start accepts many
+  tweaks, stable mode accepts few. Implement by tracking how many
+  interventions the user manually undid via slash-commands.
+* **Session vs Global memory (PRD §6)** — session state wiped per run;
+  global state only promoted if a fix worked across ≥2 sessions.
+* **TUI widget** — a collapsible Admiral panel showing recent findings
+  and their outcomes, so the user can audit the supervisor.
+
+## 9. Continuity Notes (if this session is lost)
+
+If you restart mid-Phase-2:
+* **What ships:** `drydock/admiral/` (Phase 1, working) + PRD (this
+  file). Check `git log --oneline -20` — Phase 1 commit should name
+  "Admiral Phase 1".
+* **What's missing:** `drydock/admiral/llm_analyzer.py` (local LLM)
+  and `drydock/admiral/opus_escalator.py` (Claude Code fallback).
+  Neither exists yet — start them from the Phase 2 section above.
+* **Audit log:** `~/.vibe/logs/admiral_history.log` shows every
+  intervention Admiral has applied in real user sessions.
+* **User directives recorded so far in this session:**
+  - Architecture: option C (in-process Textual worker).
+  - Approval: auto-apply, no Y/N dialog.
+  - Phase 2: Admiral uses local LLM first; escalates to Claude Code
+    (Opus) when stumped.
+  - Keep updating this PRD as work progresses so a session loss
+    doesn't cost context.
+
+***
+

{drydock_cli-2.6.136 → drydock_cli-2.6.138}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.6.136
+Version: 2.6.138
 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.6.138/drydock/admiral/__init__.py

@@ -0,0 +1,15 @@
+"""Admiral — meta-controller that supervises drydock sessions.
+
+Phase 1: heuristic loop and struggle detection, auto-applied interventions
+via the existing `_inject_system_note` channel. All interventions are
+logged to `~/.vibe/logs/admiral_history.log` for post-hoc review.
+
+The detectors read the live message list of an AgentLoop; the worker
+runs as a Textual background task so it lives in the same event loop
+as the agent (no threading, no IPC). See Admiral.md for the PRD.
+"""
+from __future__ import annotations
+
+from drydock.admiral.worker import AdmiralWorker, attach
+
+__all__ = ["AdmiralWorker", "attach"]

drydock_cli-2.6.138/drydock/admiral/detectors.py

@@ -0,0 +1,104 @@
+"""Heuristic detectors that inspect the live message list.
+
+Each detector is a pure function: take the messages, return a
+`Finding(code, directive)` if it fires, or `None`. Findings are
+idempotent within a short window — callers dedup before intervening.
+"""
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+from drydock.core.types import LLMMessage, Role
+
+
+WRITE_TOOLS: frozenset[str] = frozenset({"write_file", "search_replace", "edit_file"})
+
+
+@dataclass(frozen=True)
+class Finding:
+    code: str          # stable ID used for dedup, e.g. "loop:write_file:/p/x.py"
+    directive: str     # text to inject into the conversation
+
+
+def _tool_sig(tc) -> str:  # ToolCall — keep loose to avoid circular import
+    name = tc.function.name or ""
+    args = tc.function.arguments or ""
+    return f"{name}::{args}"
+
+
+def detect_tool_call_loop(messages: Sequence[LLMMessage], window: int = 3) -> Finding | None:
+    """Fires when the last `window` assistant tool calls are byte-identical.
+
+    Drydock already has its own loop prevention; this catches the cases
+    where the existing system warns-but-doesn't-stop and the model
+    ignored the warning.
+    """
+    sigs: list[str] = []
+    for m in reversed(messages):
+        if m.role != Role.assistant or not m.tool_calls:
+            continue
+        for tc in m.tool_calls:
+            sigs.append(_tool_sig(tc))
+            if len(sigs) >= window:
+                break
+        if len(sigs) >= window:
+            break
+    if len(sigs) < window:
+        return None
+    if len(set(sigs)) != 1:
+        return None
+    sig = sigs[0]
+    return Finding(
+        code=f"loop:{sig[:80]}",
+        directive=(
+            f"Admiral: you have called the same tool with identical arguments "
+            f"{window} times in a row. The next call will almost certainly "
+            f"produce the same result. Stop this path, try a different "
+            f"approach, or tell the user what's blocking you."
+        ),
+    )
+
+
+def detect_struggle(messages: Sequence[LLMMessage], threshold: int = 20) -> Finding | None:
+    """Fires when `threshold` tool calls have happened without any write.
+
+    Reading + grepping forever without writing code is the classic
+    "stuck exploring" failure mode.
+    """
+    calls_since_write = 0
+    last_write_tool: str | None = None
+    for m in messages:
+        if m.role != Role.assistant or not m.tool_calls:
+            continue
+        for tc in m.tool_calls:
+            name = tc.function.name or ""
+            if name in WRITE_TOOLS:
+                calls_since_write = 0
+                last_write_tool = name
+            else:
+                calls_since_write += 1
+    if calls_since_write < threshold:
+        return None
+    hint = (
+        "Either (a) you already have enough context — commit to a plan and "
+        "start writing code now, or (b) you're genuinely stuck — stop and "
+        "report what's blocking you to the user."
+    )
+    return Finding(
+        code=f"struggle:{calls_since_write}:{last_write_tool or 'none'}",
+        directive=(
+            f"Admiral: you have made {calls_since_write} tool calls without "
+            f"writing or editing any file. {hint}"
+        ),
+    )
+
+
+def run_all(messages: Sequence[LLMMessage]) -> list[Finding]:
+    """Run every detector and return all findings that fire."""
+    results: list[Finding] = []
+    for fn in (detect_tool_call_loop, detect_struggle):
+        f = fn(messages)
+        if f is not None:
+            results.append(f)
+    return results

drydock_cli-2.6.138/drydock/admiral/history.py

@@ -0,0 +1,23 @@
+"""Plain-text audit log for every intervention Admiral applies.
+
+Per the PRD: "Every change Admiral makes to Drydock's state must be
+written to a plain-text admiral_history.log." Kept simple on purpose —
+no JSON, no rotation logic, just append-only timestamped lines.
+"""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+def _log_path() -> Path:
+    d = Path.home() / ".vibe" / "logs"
+    d.mkdir(parents=True, exist_ok=True)
+    return d / "admiral_history.log"
+
+
+def append(event: str, detail: str) -> None:
+    ts = datetime.now(timezone.utc).isoformat(timespec="seconds")
+    line = f"{ts} | {event} | {detail}\n"
+    with _log_path().open("a") as f:
+        f.write(line)

drydock_cli-2.6.138/drydock/admiral/interventions.py

@@ -0,0 +1,21 @@
+"""Apply interventions by injecting into the running AgentLoop.
+
+The injection path is the same `_inject_system_note` drydock's own
+safety checks use — Admiral is just another source of directives.
+Every intervention writes to the audit log.
+"""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from drydock.admiral import history
+from drydock.admiral.detectors import Finding
+
+if TYPE_CHECKING:
+    from drydock.core.agent_loop import AgentLoop
+
+
+def apply(agent_loop: AgentLoop, finding: Finding) -> None:
+    """Inject the finding's directive into the live conversation."""
+    agent_loop._inject_system_note(finding.directive)
+    history.append("intervention", f"{finding.code} :: {finding.directive[:160]}")

drydock_cli-2.6.138/drydock/admiral/worker.py

@@ -0,0 +1,93 @@
+"""AdmiralWorker — periodic supervisor running inside the Textual app.
+
+Phase 1 behaviour:
+- Every ~5s, inspect the live AgentLoop message list.
+- Run all detectors.
+- For each finding NOT seen in the last `DEDUP_WINDOW_SEC` seconds,
+  auto-apply the intervention.
+- Log both findings (with auto-apply decision) and bootstrap/stop
+  events to ~/.vibe/logs/admiral_history.log.
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from typing import TYPE_CHECKING
+
+from drydock.admiral import detectors, history, interventions
+
+if TYPE_CHECKING:
+    from drydock.core.agent_loop import AgentLoop
+
+logger = logging.getLogger(__name__)
+
+POLL_INTERVAL_SEC = 5.0
+DEDUP_WINDOW_SEC = 60.0
+
+
+class AdmiralWorker:
+    """Async task that supervises one AgentLoop.
+
+    Not a Textual worker class — it's just an asyncio.Task you spawn
+    from inside the TUI app's event loop. Lives alongside the agent,
+    stops when the agent stops.
+    """
+
+    def __init__(self, agent_loop: AgentLoop) -> None:
+        self.agent_loop = agent_loop
+        self._task: asyncio.Task | None = None
+        self._recent_findings: dict[str, float] = {}  # code -> timestamp
+
+    def start(self) -> None:
+        if self._task is not None and not self._task.done():
+            return
+        self._task = asyncio.create_task(self._run(), name="admiral-worker")
+        history.append("bootstrap", "AdmiralWorker started")
+
+    def stop(self) -> None:
+        if self._task is None:
+            return
+        self._task.cancel()
+        self._task = None
+        history.append("shutdown", "AdmiralWorker stopped")
+
+    async def _run(self) -> None:
+        try:
+            while True:
+                await asyncio.sleep(POLL_INTERVAL_SEC)
+                try:
+                    self._tick()
+                except Exception as e:
+                    # Detector bugs must never crash the agent — log and continue.
+                    logger.warning("Admiral tick error: %s", e)
+                    history.append("error", f"tick failed: {e}")
+        except asyncio.CancelledError:
+            raise
+
+    def _tick(self) -> None:
+        now = time.monotonic()
+        # Garbage-collect old dedup entries so long sessions don't leak.
+        self._recent_findings = {
+            code: ts for code, ts in self._recent_findings.items()
+            if now - ts < DEDUP_WINDOW_SEC
+        }
+        findings = detectors.run_all(list(self.agent_loop.messages))
+        for f in findings:
+            last = self._recent_findings.get(f.code)
+            if last is not None and (now - last) < DEDUP_WINDOW_SEC:
+                continue
+            self._recent_findings[f.code] = now
+            interventions.apply(self.agent_loop, f)
+
+
+def attach(agent_loop: AgentLoop) -> AdmiralWorker:
+    """Start an AdmiralWorker supervising the given agent loop.
+
+    Returns the worker handle so the caller can stop it on shutdown.
+    Safe to call multiple times — a fresh worker replaces any prior
+    one, but that's the caller's responsibility to track.
+    """
+    worker = AdmiralWorker(agent_loop)
+    worker.start()
+    return worker

{drydock_cli-2.6.136 → drydock_cli-2.6.138}/drydock/cli/textual_ui/app.py

@@ -288,6 +288,7 @@ class VibeApp(App):  # noqa: PLR0904
         self._last_escape_time: float | None = None
         self._banner: Banner | None = None
         self._whats_new_message: WhatsNewMessage | None = None
+        self._admiral = None  # type: ignore[var-annotated]
         self._cached_messages_area: Widget | None = None
         self._cached_chat: ChatScroll | None = None
         self._cached_loading_area: Widget | None = None
@@ -353,6 +354,14 @@ class VibeApp(App):  # noqa: PLR0904
         self.agent_loop.set_user_input_callback(self._user_input_callback)
         self._refresh_profile_widgets()
 
+        try:
+            from drydock.admiral import attach as _admiral_attach
+            self._admiral = _admiral_attach(self.agent_loop)
+        except Exception as e:
+            # Admiral must never prevent the TUI from starting.
+            import logging
+            logging.getLogger(__name__).warning("Admiral failed to start: %s", e)
+
         chat_input_container = self.query_one(ChatInputContainer)
         chat_input_container.focus_input()
         await self._resolve_plan()

{drydock_cli-2.6.136 → drydock_cli-2.6.138}/drydock/cli/textual_ui/widgets/messages.py

@@ -114,32 +114,63 @@ class StreamingMessageBase(Static):
 _INLINE_ENUM_RE = re.compile(r" (?=\d{1,2}\. [A-Z])")
 _INLINE_HEADING_RE = re.compile(r" (?=\*\*[A-Z][A-Za-z ]{1,20}:\*\*)")
 _INLINE_DASH_BULLET_RE = re.compile(r"(?<=[.!?]) (?=- [A-Z])")
+_SENTENCE_BOUNDARY_RE = re.compile(r"(?<=[.!?]) (?=[A-Z])")
+_INLINE_CAPWORD_HEADING_RE = re.compile(
+    r"(?<=[.!?]) (?=[A-Z][A-Za-z]{1,15}:\s)"
+)
+
+
+def _sentence_chunks(text: str, group: int = 2) -> str:
+    """Break a long flat string into paragraphs every `group` sentences.
+
+    Conservative: only fires when there are at least 2 sentences to
+    split between. Splits on real sentence boundaries (`. `, `! `, `? `
+    followed by a capital).
+    """
+    sentences = _SENTENCE_BOUNDARY_RE.split(text)
+    if len(sentences) < 2:
+        return text
+    paragraphs: list[str] = []
+    for i in range(0, len(sentences), group):
+        paragraphs.append(" ".join(sentences[i:i + group]))
+    return "\n\n".join(paragraphs)
 
 
 def _break_walls_of_text(text: str) -> str:
-    """Insert line breaks before inline enumerations and bold headings
-    in a flat string with no newlines.
-
-    Gemma 4 often emits responses like `Changes: 1. Added X 2. Added Y
-    3. Fixed Z` as a single paragraph with zero `\\n`. The Markdown
-    widget renders that as one long line, which users correctly call
-    "a wall of text". We can't insert newlines the model didn't write
-    inside a code fence, but we can break up inline numbered items
-    (` 1. Foo 2. Bar `) and inline bold headings (` **Usage:** `) into
-    separate markdown blocks by injecting `\\n` before the enumeration
-    or heading marker. Conservative patterns only — must match a space
-    followed by `\\d+\\. [A-Z]` or `**Heading:**`.
-
-    Runs OUTSIDE code fences only.
+    """Make flat, low-newline assistant responses readable.
+
+    Gemma 4 regularly emits responses with zero `\\n` — either a block
+    of enumerated items jammed together (`Changes: 1. A 2. B 3. C`) or
+    a long paragraph of prose (`I fixed X. The Y class now uses Z.
+    All tests pass.`). The Markdown widget renders both as one line.
+
+    Strategy, applied in order:
+    1. Break before inline `**Heading:**` markers.
+    2. Break before inline numbered items (` 1. Foo 2. Bar`).
+    3. Break before inline `CapWord:` mini-headings (`Changes: ...`).
+    4. If still a wall (long + zero newlines), split every 2 sentences
+       at real sentence boundaries so readers get paragraph breaks.
+
+    Conservative guards: nothing fires unless the chunk is >200 chars
+    and has fewer than 3 newlines. Short responses and already-
+    structured markdown pass through untouched.
     """
-    if not text or "\n" in text and text.count("\n") >= 2:
+    if not text or len(text) < 200:
         return text
-    # Only intervene for "wall of text" — long, low-newline content.
-    if len(text) < 200:
+    nl = text.count("\n")
+    if nl >= 3:
         return text
-    out = _INLINE_ENUM_RE.sub("\n", text)
-    out = _INLINE_HEADING_RE.sub("\n\n", out)
+    out = _INLINE_HEADING_RE.sub("\n\n", text)
+    out = _INLINE_ENUM_RE.sub("\n", out)
     out = _INLINE_DASH_BULLET_RE.sub("\n", out)
+    out = _INLINE_CAPWORD_HEADING_RE.sub("\n\n", out)
+    # If inline markers didn't produce any breaks AND the text is long
+    # enough that one paragraph hurts readability, split at sentence
+    # boundaries. group=1 = each sentence on its own paragraph (most
+    # aggressive — user-requested in issue #8 reopen). Threshold is
+    # 250 so medium-length responses also get paragraphs.
+    if "\n" not in out and len(out) > 250:
+        out = _sentence_chunks(out, group=1)
     return out
 
 
@@ -166,10 +197,9 @@ def _preserve_line_breaks(text: str) -> str:
     """
     if not text:
         return text
-    # First pass: if the whole chunk has no newlines, try to rescue
-    # inline-enumeration wall-of-text.
-    if "\n" not in text:
-        text = _break_walls_of_text(text)
+    # First pass: rescue wall-of-text responses (flat prose, inline
+    # enumerations, inline bold headings). See _break_walls_of_text.
+    text = _break_walls_of_text(text)
     out: list[str] = []
     in_fence = False
     lines = text.split("\n")

{drydock_cli-2.6.136 → drydock_cli-2.6.138}/pyproject.toml

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

drydock_cli-2.6.138/tests/test_admiral.py

@@ -0,0 +1,75 @@
+"""Unit tests for Admiral's Phase 1 detectors."""
+from __future__ import annotations
+
+from drydock.admiral.detectors import detect_struggle, detect_tool_call_loop, run_all
+from drydock.core.types import FunctionCall, LLMMessage, Role, ToolCall
+
+
+def _assistant(tool: str, args: str = "{}") -> LLMMessage:
+    return LLMMessage(
+        role=Role.assistant,
+        content="",
+        tool_calls=[ToolCall(function=FunctionCall(name=tool, arguments=args))],
+    )
+
+
+def test_loop_fires_on_three_identical_tool_calls() -> None:
+    msgs = [
+        LLMMessage(role=Role.user, content="go"),
+        _assistant("read_file", '{"path":"x.py"}'),
+        LLMMessage(role=Role.tool, content="result"),
+        _assistant("read_file", '{"path":"x.py"}'),
+        LLMMessage(role=Role.tool, content="result"),
+        _assistant("read_file", '{"path":"x.py"}'),
+        LLMMessage(role=Role.tool, content="result"),
+    ]
+    f = detect_tool_call_loop(msgs)
+    assert f is not None
+    assert "Admiral" in f.directive
+    assert f.code.startswith("loop:")
+
+
+def test_loop_no_fire_on_varied_args() -> None:
+    msgs = [
+        _assistant("read_file", '{"path":"x.py"}'),
+        LLMMessage(role=Role.tool, content="r"),
+        _assistant("read_file", '{"path":"y.py"}'),
+        LLMMessage(role=Role.tool, content="r"),
+        _assistant("read_file", '{"path":"z.py"}'),
+        LLMMessage(role=Role.tool, content="r"),
+    ]
+    assert detect_tool_call_loop(msgs) is None
+
+
+def test_struggle_fires_after_many_reads_without_write() -> None:
+    msgs: list[LLMMessage] = [LLMMessage(role=Role.user, content="build it")]
+    for i in range(25):
+        msgs.append(_assistant("read_file", f'{{"path":"f{i}.py"}}'))
+        msgs.append(LLMMessage(role=Role.tool, content="..."))
+    f = detect_struggle(msgs)
+    assert f is not None
+    assert "without writing" in f.directive
+
+
+def test_struggle_resets_on_write() -> None:
+    msgs: list[LLMMessage] = []
+    for i in range(15):
+        msgs.append(_assistant("read_file", f'{{"path":"f{i}.py"}}'))
+        msgs.append(LLMMessage(role=Role.tool, content="..."))
+    msgs.append(_assistant("write_file", '{"path":"new.py","content":"x"}'))
+    msgs.append(LLMMessage(role=Role.tool, content="ok"))
+    for i in range(3):
+        msgs.append(_assistant("read_file", f'{{"path":"check{i}.py"}}'))
+        msgs.append(LLMMessage(role=Role.tool, content="..."))
+    assert detect_struggle(msgs) is None
+
+
+def test_run_all_returns_multiple_findings() -> None:
+    msgs: list[LLMMessage] = []
+    for i in range(25):
+        msgs.append(_assistant("read_file", '{"path":"x.py"}'))  # same args -> loop
+        msgs.append(LLMMessage(role=Role.tool, content="..."))
+    findings = run_all(msgs)
+    codes = {f.code.split(":")[0] for f in findings}
+    assert "loop" in codes
+    assert "struggle" in codes