drydock-cli 2.8.17__tar.gz → 2.8.19__tar.gz

drydock_cli-2.8.19/.auto_release.lock

@@ -0,0 +1 @@
+739611

{drydock_cli-2.8.17 → drydock_cli-2.8.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.8.17
+Version: 2.8.19
 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
@@ -284,7 +284,7 @@ First run creates a config at `~/.drydock/config.toml` and prompts for your prov
 - **Loop Detection**: Advisory-only detection that nudges the model away from repetitive actions without blocking.
 - **Conda/Pip Support**: Auto-approves `pip install`, `conda install`, `pytest`, and other dev commands.
 - **Bundled Skills**: Ships with skills like `create-presentation` for PowerPoint generation.
-- **MCP Support**: Connect Model Context Protocol servers for extended capabilities.
+- **MCP Support**: Connect Model Context Protocol servers via the `/mcp` slash command or `~/.drydock/config.toml`. See [MCP Servers](#mcp-servers).
 - **Safety First**: Tool execution approval with `--dangerously-skip-permissions` for full auto-approve.
 
 ### Built-in Agents
@@ -379,14 +379,62 @@ DryDock discovers skills from:
 
 ### MCP Servers
 
+DryDock can connect to any Model Context Protocol server. Tools from a server `foo` show up as `foo__<tool_name>` in the agent's tool list. Two ways to add one:
+
+#### Option A — `/mcp` slash command (recommended)
+
+Inside the TUI:
+
+```
+/mcp                                                       # list configured servers + usage
+/mcp examples                                              # ready-to-paste examples
+/mcp add stdio fetch_server uvx mcp-server-fetch
+/mcp add stdio filesystem npx -y @modelcontextprotocol/server-filesystem /data
+/mcp add http weather https://mcp.example.com
+/mcp add streamable-http myapi https://api.example.com/mcp
+/mcp remove fetch_server
+```
+
+The command writes to `~/.drydock/config.toml`. Restart DryDock to load new servers.
+
+#### Option B — edit `~/.drydock/config.toml` directly
+
+Use this for advanced fields (auth headers, env-var API keys, custom timeouts, `sampling_enabled`). Three transports: `stdio`, `http`, `streamable-http`.
+
 ```toml
 [[mcp_servers]]
 name = "fetch_server"
 transport = "stdio"
 command = "uvx"
 args = ["mcp-server-fetch"]
+
+[[mcp_servers]]
+name = "filesystem"
+transport = "stdio"
+command = "npx"
+args = ["-y", "@modelcontextprotocol/server-filesystem", "/data"]
+env = { LOG_LEVEL = "info" }
+startup_timeout_sec = 10.0
+tool_timeout_sec = 60.0
+sampling_enabled = true
+
+[[mcp_servers]]
+name = "github"
+transport = "streamable-http"
+url = "https://api.githubcopilot.com/mcp"
+api_key_env = "GITHUB_TOKEN"                # reads token from this env var
+api_key_header = "Authorization"
+api_key_format = "Bearer {token}"
+
+[[mcp_servers]]
+name = "weather"
+transport = "http"
+url = "https://mcp.weather.example.com"
+headers = { "X-Tenant" = "drydock" }
 ```
 
+Verify a server loaded by running `/help` inside the TUI and checking for `<name>__*` prefixed tools. Server errors show up in `~/.drydock/logs/`.
+
 ## Testing
 
 DryDock uses a **shakedown harness** (`scripts/shakedown.py`) that drives the real TUI via pexpect and judges on user-perceptible criteria — not tool-call counts.

{drydock_cli-2.8.17 → drydock_cli-2.8.19}/README.md

@@ -229,7 +229,7 @@ First run creates a config at `~/.drydock/config.toml` and prompts for your prov
 - **Loop Detection**: Advisory-only detection that nudges the model away from repetitive actions without blocking.
 - **Conda/Pip Support**: Auto-approves `pip install`, `conda install`, `pytest`, and other dev commands.
 - **Bundled Skills**: Ships with skills like `create-presentation` for PowerPoint generation.
-- **MCP Support**: Connect Model Context Protocol servers for extended capabilities.
+- **MCP Support**: Connect Model Context Protocol servers via the `/mcp` slash command or `~/.drydock/config.toml`. See [MCP Servers](#mcp-servers).
 - **Safety First**: Tool execution approval with `--dangerously-skip-permissions` for full auto-approve.
 
 ### Built-in Agents
@@ -324,14 +324,62 @@ DryDock discovers skills from:
 
 ### MCP Servers
 
+DryDock can connect to any Model Context Protocol server. Tools from a server `foo` show up as `foo__<tool_name>` in the agent's tool list. Two ways to add one:
+
+#### Option A — `/mcp` slash command (recommended)
+
+Inside the TUI:
+
+```
+/mcp                                                       # list configured servers + usage
+/mcp examples                                              # ready-to-paste examples
+/mcp add stdio fetch_server uvx mcp-server-fetch
+/mcp add stdio filesystem npx -y @modelcontextprotocol/server-filesystem /data
+/mcp add http weather https://mcp.example.com
+/mcp add streamable-http myapi https://api.example.com/mcp
+/mcp remove fetch_server
+```
+
+The command writes to `~/.drydock/config.toml`. Restart DryDock to load new servers.
+
+#### Option B — edit `~/.drydock/config.toml` directly
+
+Use this for advanced fields (auth headers, env-var API keys, custom timeouts, `sampling_enabled`). Three transports: `stdio`, `http`, `streamable-http`.
+
 ```toml
 [[mcp_servers]]
 name = "fetch_server"
 transport = "stdio"
 command = "uvx"
 args = ["mcp-server-fetch"]
+
+[[mcp_servers]]
+name = "filesystem"
+transport = "stdio"
+command = "npx"
+args = ["-y", "@modelcontextprotocol/server-filesystem", "/data"]
+env = { LOG_LEVEL = "info" }
+startup_timeout_sec = 10.0
+tool_timeout_sec = 60.0
+sampling_enabled = true
+
+[[mcp_servers]]
+name = "github"
+transport = "streamable-http"
+url = "https://api.githubcopilot.com/mcp"
+api_key_env = "GITHUB_TOKEN"                # reads token from this env var
+api_key_header = "Authorization"
+api_key_format = "Bearer {token}"
+
+[[mcp_servers]]
+name = "weather"
+transport = "http"
+url = "https://mcp.weather.example.com"
+headers = { "X-Tenant" = "drydock" }
 ```
 
+Verify a server loaded by running `/help` inside the TUI and checking for `<name>__*` prefixed tools. Server errors show up in `~/.drydock/logs/`.
+
 ## Testing
 
 DryDock uses a **shakedown harness** (`scripts/shakedown.py`) that drives the real TUI via pexpect and judges on user-perceptible criteria — not tool-call counts.

{drydock_cli-2.8.17 → drydock_cli-2.8.19}/SOVEREIGN_PRD.md

@@ -80,6 +80,9 @@ A sovereign AI system that:
 - Learns customer-specific knowledge
 - Performs coding and reasoning tasks autonomously
 - Self-diagnoses failures (Admiral) and self-improves (MetaHarness, evaluator)
+- **Operates with engineered curiosity** — actively detects its own gaps,
+  retrieves before asserting, ingests unfamiliar context, and treats
+  surprise as signal worth chasing rather than noise to suppress
 - Improves continuously without phoning home
 
 ---
@@ -363,6 +366,99 @@ Already partially shipped — the system already self-observes.
 
 ---
 
+## 5.7 Curiosity Layer — engineered intellectual drive
+
+GraphRAG, Deep Noir, and the HLE benchmark together expose a structural
+weakness in Gemma 4 and most small local models: they answer from prior
+when they should retrieve, plateau on familiar patterns, and treat
+"unknown" as something to guess past rather than something to investigate.
+The Curiosity Layer is a first-class drydock directive — both a guiding
+principle in the system prompt and a concrete subsystem — that converts
+that weakness into a feedback loop.
+
+**Operating definition (carries into the system prompt):**
+
+> Curiosity is an inquisitive, often insatiable desire to understand the
+> unknown — from everyday questions to scientific discovery. In drydock
+> this means: when you notice a gap, you close it; when you encounter
+> something unfamiliar, you investigate before asserting; when you have
+> spare cycles, you explore the corpus rather than idle.
+
+**Behaviors required of the agent (enforced via prompt + Deep Noir vector
+candidate + tool wiring):**
+
+1. **Retrieve before answering on unfamiliar terms.** Any user message
+   containing a named entity, paper title, identifier, API, or symbol
+   not present in recent context triggers an automatic `retrieve` call
+   against GraphRAG before the first content token. Low-confidence
+   retrieval triggers a second pass against the arXiv corpus
+   (`/data3/arxiv_corpus/graphrag.sqlite`) instead of falling back to
+   `web_search`. Fixes the failure mode logged in
+   `project_graphrag_underused.md` (Gemma 4 defaults to web_search on
+   general-knowledge HLE questions).
+2. **Treat surprise as signal, not noise.** When the model's own
+   probability estimate disagrees with retrieved evidence, with a tool
+   result, or with an HLE judge verdict, the disagreement is logged to
+   the curiosity queue (`~/.drydock/dispatch/curiosity.jsonl`) and
+   surfaces in the next overnight `autonomous_review` tick as a
+   candidate for: GraphRAG ingest, prompt refinement, Deep Noir vector
+   training data, or LoRA candidate.
+3. **Investigate before asking.** When the user request is
+   under-specified, the agent first reads the project (Glob + Read on
+   plausible files, `retrieve` against GraphRAG) and proposes a
+   concrete interpretation. `ask_user_question` only fires after at
+   least one investigation pass — never as a first move on ambiguity.
+4. **Explore on idle.** When drydock is idle for > N minutes and the
+   classifier dispatch queues are non-empty, the agent runs a single
+   exploratory cycle: pick the highest-priority pattern, ingest fresh
+   logs into GraphRAG, generate one hypothesis, log to
+   `~/.drydock/curiosity_log.md`. Bounded by a tokens-per-day budget
+   so curiosity does not starve user work.
+5. **Open mindset on conflict.** When new evidence contradicts a
+   previously asserted answer, the agent prefers the new evidence and
+   issues a correction in the same turn. Extends the existing
+   "Retrieval vs. Prior" guidance in §10 into an active rule.
+
+**Curiosity subsystem deliverables (Phase 3, alongside Deep Noir):**
+
+- `drydock.curiosity` module — gap detector, surprise scorer, dispatch
+  writer. Reuses classifier infrastructure from §5.6.
+- `~/.drydock/dispatch/curiosity.jsonl` queue + consumer wired into
+  `autonomous_review.sh`.
+- System-prompt section embedding the five behaviors above, kept short
+  enough for Gemma 4's 20-line prompt budget (`gemma4.md`).
+- Deep Noir vector candidate: "exploration" mode — bias toward retrieval,
+  hypothesis enumeration, and reading-before-writing. Trained from
+  curiosity-log traces once Deep Noir vector training lands.
+- HLE/eval integration: every HLE failure where the judge reasoning
+  contains "no answer extracted" or "incorrect prior" is auto-enqueued
+  as a curiosity item — the eval becomes a growth signal, not just
+  a scoreboard.
+
+**Anti-patterns explicitly forbidden:**
+
+- Curiosity does **not** mean asking the user more questions. The
+  default is to investigate, not interrogate.
+- Curiosity does **not** override the "advisory-only" rule. Exploration
+  cycles never block user work; they consume idle cycles only.
+- Curiosity must **not** become rumination — the tokens-per-day budget
+  exists specifically to prevent endless exploration loops on a single
+  unfamiliar term.
+
+**Acceptance criteria:**
+
+- `retrieve` is called on ≥ 80 % of HLE questions before any content
+  token (measured via execution traces, Phase 3).
+- `~/.drydock/dispatch/curiosity.jsonl` accumulates ≥ 10 items per
+  active week without operator priming.
+- `autonomous_review` ships ≥ 1 prompt/AGENTS.md/vector update per week
+  that originated from a curiosity-queue item (not a stress-run signal).
+- HLE general-knowledge category score lifts measurably vs. the
+  May 2026 baseline (1/20 = 5 %, 18/20 "empty"); target ≥ 25 %
+  in Phase 3, ≥ 40 % in Phase 4.
+
+---
+
 # 6. Adaptive Failure Logic
 
 ```text
@@ -383,6 +479,18 @@ If loops detected:
    → loop-break sampling (temp+0.3/0.5, freq_pen 0.4–0.7, fresh seed)
    → planner reset + diversity strategy
    → only escalates to FORCE_STOP on pure no-op duplicates
+
+If unfamiliar term / named entity / identifier in user input:
+   → mandatory retrieve pass (GraphRAG, then arXiv corpus)
+   → web_search only after both local retrievers return low confidence
+
+If model output contradicts retrieved evidence / tool result / judge verdict:
+   → log to ~/.drydock/dispatch/curiosity.jsonl
+   → autonomous_review picks it up next tick as ingest / prompt / vector candidate
+
+If idle > N minutes AND classifier queues non-empty:
+   → one exploratory cycle (bounded by tokens-per-day budget)
+   → ingest, hypothesis, curiosity_log entry — never a user-visible action
 ```
 
 All logic is **advisory-first**. Hard stops are reserved for objectively useless
@@ -551,6 +659,9 @@ mitigates several of the failure classes already in `MODEL_SHORTCOMINGS.md`.
 | Customer cloud dependency             | −70 %  | Brand promise, qualitative |
 | Task completion rate (interactive)    | +35 %  | Current shakedown baseline |
 | SWE-bench file match                  | maintain ≥70 % | 70 % current        |
+| `retrieve` calls before content (HLE) | ≥80 %  | <5 % observed May 2026     |
+| Curiosity-queue items shipped / week  | ≥1     | 0 — queue not built yet    |
+| HLE general-knowledge score           | ≥25 % Phase 3, ≥40 % Phase 4 | 5 % (1/20 May 2026) |
 
 Metrics with "TBD" baselines are explicitly required to be **measured** before
 Phase 2 begins, not estimated.

{drydock_cli-2.8.17 → drydock_cli-2.8.19}/drydock/cli/commands.py

@@ -125,6 +125,15 @@ class CommandRegistry:
                             "/steering off | /steering list).",
                 handler="_steering_command",
             ),
+            "mcp": Command(
+                aliases=frozenset(["/mcp"]),
+                description="Configure MCP servers in ~/.drydock/config.toml "
+                            "(usage: /mcp | /mcp add stdio <name> <cmd...> | "
+                            "/mcp add http <name> <url> | "
+                            "/mcp add streamable-http <name> <url> | "
+                            "/mcp remove <name> | /mcp examples).",
+                handler="_mcp_command",
+            ),
         }
 
         for command in excluded_commands:

{drydock_cli-2.8.17 → drydock_cli-2.8.19}/drydock/cli/textual_ui/app.py

@@ -421,20 +421,46 @@ class DrydockApp(App):  # noqa: PLR0904
         input_widget.value = ""
 
         if self._agent_running:
-            # Queue the message — join rapid-fire inputs (multi-line paste)
-            if not hasattr(self, "_pending_messages"):
-                self._pending_messages: list[str] = []
-            import time
-            now = time.time()
-            last_queue_time = getattr(self, "_last_queue_time", 0)
-            if now - last_queue_time < 0.5 and self._pending_messages:
-                # Rapid input (< 500ms apart) = likely paste — join with newline
-                self._pending_messages[-1] += "\n" + value
-            else:
-                self._pending_messages.append(value)
-            self._last_queue_time = now
+            # Slash commands and bash escapes can't be folded into a running
+            # turn — they need their own worker. Keep the end-of-turn queue
+            # for those. Everything else (plain text) goes straight into the
+            # agent's context via `queue_user_injection`, matching Claude
+            # Code's "type while busy" behavior: the in-flight task keeps
+            # running, and the model sees the new message at the next turn
+            # boundary without restarting.
+            is_command = value.startswith("/") or value.startswith("!") or (
+                value.startswith("&") and self.config.nuage_enabled
+            )
+
+            if is_command:
+                if not hasattr(self, "_pending_messages"):
+                    self._pending_messages: list[str] = []
+                import time
+                now = time.time()
+                last_queue_time = getattr(self, "_last_queue_time", 0)
+                if now - last_queue_time < 0.5 and self._pending_messages:
+                    self._pending_messages[-1] += "\n" + value
+                else:
+                    self._pending_messages.append(value)
+                self._last_queue_time = now
+                preview = value[:60] + "..." if len(value) > 60 else value
+                self.notify(
+                    f"Queued for after current task: \"{preview}\" "
+                    f"({len(self._pending_messages)} pending)"
+                )
+                return
+
+            # Plain text → inject into the running agent's context. Render
+            # a user-message bubble immediately so the UI shows what landed,
+            # and notify so the user knows it didn't displace the current
+            # work.
+            self.agent_loop.queue_user_injection(value)
+            await self._mount_and_scroll(UserMessage(value))
             preview = value[:60] + "..." if len(value) > 60 else value
-            self.notify(f"Queued: \"{preview}\" ({len(self._pending_messages)} pending)")
+            self.notify(
+                f"Sent to running agent: \"{preview}\" "
+                f"(will be picked up at the next turn)"
+            )
             return
 
         if value.startswith("!"):
@@ -1414,11 +1440,11 @@ class DrydockApp(App):  # noqa: PLR0904
             pass
 
         # Read existing config
-        import tomli
+        import tomllib
         existing = {}
         if config_path.exists():
             try:
-                existing = tomli.loads(config_path.read_text())
+                existing = tomllib.loads(config_path.read_text())
             except Exception:
                 pass
 
@@ -1462,6 +1488,176 @@ class DrydockApp(App):  # noqa: PLR0904
             )
         )
 
+    async def _mcp_command(self, args: str = "") -> None:
+        """Configure MCP servers in ~/.drydock/config.toml."""
+        import shlex
+        import tomllib
+        import tomli_w
+
+        config_path = Path.home() / ".drydock" / "config.toml"
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+
+        def _load() -> dict:
+            if not config_path.exists():
+                return {}
+            try:
+                return tomllib.loads(config_path.read_text())
+            except Exception:
+                return {}
+
+        def _save(data: dict) -> None:
+            config_path.write_text(tomli_w.dumps(data))
+
+        def _render_servers(servers: list[dict]) -> str:
+            if not servers:
+                return "_(no MCP servers configured)_"
+            lines = []
+            for s in servers:
+                name = s.get("name", "?")
+                transport = s.get("transport", "?")
+                if transport == "stdio":
+                    cmd = s.get("command", "")
+                    if isinstance(cmd, list):
+                        cmd = " ".join(cmd)
+                    extra = " ".join(s.get("args", []) or [])
+                    target = f"`{cmd} {extra}`".strip()
+                else:
+                    target = f"`{s.get('url', '')}`"
+                lines.append(f"- **{name}** ({transport}) → {target}")
+            return "\n".join(lines)
+
+        parts = shlex.split(args) if args.strip() else []
+        sub = parts[0].lower() if parts else "list"
+
+        if sub in ("list", ""):
+            data = _load()
+            servers = data.get("mcp_servers", []) or []
+            msg = (
+                "### MCP servers\n\n"
+                f"Config: `{config_path}`\n\n"
+                f"{_render_servers(servers)}\n\n"
+                "**Commands:**\n"
+                "- `/mcp add stdio <name> <command> [args...]`\n"
+                "- `/mcp add http <name> <url>`\n"
+                "- `/mcp add streamable-http <name> <url>`\n"
+                "- `/mcp remove <name>`\n"
+                "- `/mcp examples`\n\n"
+                "_Restart Drydock after changes to load new servers._"
+            )
+            await self._mount_and_scroll(UserCommandMessage(msg))
+            return
+
+        if sub == "examples":
+            await self._mount_and_scroll(UserCommandMessage(
+                "### MCP server examples\n\n"
+                "**stdio (local process):**\n"
+                "```\n"
+                "/mcp add stdio filesystem npx -y "
+                "@modelcontextprotocol/server-filesystem /data\n"
+                "```\n\n"
+                "**HTTP:**\n"
+                "```\n"
+                "/mcp add http weather https://mcp.example.com\n"
+                "```\n\n"
+                "**Streamable HTTP:**\n"
+                "```\n"
+                "/mcp add streamable-http myapi https://api.example.com/mcp\n"
+                "```\n\n"
+                "For auth headers, env-var API keys, custom timeouts, or "
+                "`sampling_enabled=false`, edit `~/.drydock/config.toml` "
+                "directly. Schema: `name`, `transport`, plus `command`/"
+                "`args`/`env` (stdio) or `url`/`headers`/`api_key_env`/"
+                "`api_key_header`/`api_key_format` (http variants)."
+            ))
+            return
+
+        if sub == "remove":
+            if len(parts) < 2:
+                await self._mount_and_scroll(UserCommandMessage(
+                    "Usage: `/mcp remove <name>`"
+                ))
+                return
+            name = parts[1]
+            data = _load()
+            servers = data.get("mcp_servers", []) or []
+            new_servers = [s for s in servers if s.get("name") != name]
+            if len(new_servers) == len(servers):
+                await self._mount_and_scroll(UserCommandMessage(
+                    f"No MCP server named `{name}` found."
+                ))
+                return
+            data["mcp_servers"] = new_servers
+            _save(data)
+            await self._mount_and_scroll(UserCommandMessage(
+                f"Removed MCP server `{name}`. Restart Drydock to apply."
+            ))
+            return
+
+        if sub == "add":
+            if len(parts) < 4:
+                await self._mount_and_scroll(UserCommandMessage(
+                    "Usage:\n"
+                    "- `/mcp add stdio <name> <command> [args...]`\n"
+                    "- `/mcp add http <name> <url>`\n"
+                    "- `/mcp add streamable-http <name> <url>`"
+                ))
+                return
+            transport = parts[1].lower()
+            name = parts[2]
+            rest = parts[3:]
+
+            if transport not in ("stdio", "http", "streamable-http"):
+                await self._mount_and_scroll(UserCommandMessage(
+                    f"Unknown transport `{transport}`. "
+                    "Use `stdio`, `http`, or `streamable-http`."
+                ))
+                return
+
+            entry: dict
+            if transport == "stdio":
+                entry = {
+                    "name": name,
+                    "transport": "stdio",
+                    "command": rest[0],
+                    "args": list(rest[1:]),
+                }
+            else:
+                if len(rest) != 1:
+                    await self._mount_and_scroll(UserCommandMessage(
+                        f"Usage: `/mcp add {transport} <name> <url>`"
+                    ))
+                    return
+                entry = {
+                    "name": name,
+                    "transport": transport,
+                    "url": rest[0],
+                }
+
+            data = _load()
+            servers = data.get("mcp_servers", []) or []
+            servers = [s for s in servers if s.get("name") != name]
+            servers.append(entry)
+            data["mcp_servers"] = servers
+            _save(data)
+
+            target = (
+                f"`{entry['command']} {' '.join(entry.get('args', []))}`".strip()
+                if transport == "stdio"
+                else f"`{entry['url']}`"
+            )
+            await self._mount_and_scroll(UserCommandMessage(
+                f"Added MCP server **{name}** ({transport}) → {target}\n\n"
+                f"Config: `{config_path}`\n"
+                "Restart Drydock to load the server. Edit the file directly "
+                "for advanced fields (headers, env, api_key_env, timeouts)."
+            ))
+            return
+
+        await self._mount_and_scroll(UserCommandMessage(
+            "Usage: `/mcp {list | add <transport> <name> ... | "
+            "remove <name> | examples}`"
+        ))
+
     async def _admiral_apply_command(self, args: str = "") -> None:
         """Merge an Admiral-staged proposal branch into main."""
         import subprocess

{drydock_cli-2.8.17 → drydock_cli-2.8.19}/drydock/core/agent_loop.py

@@ -224,6 +224,15 @@ class AgentLoop:
         self._empty_responses: int = 0
         self._successful_test_runs: int = 0
 
+        # Mid-turn user injections (the Claude Code "type while busy" feature).
+        # The TUI calls `queue_user_injection()` whenever the user submits a
+        # message while the agent is mid-task. The per-turn loop drains this
+        # at the top of each iteration and folds the text into context as a
+        # SYSTEM note attached to the last tool result (the only ordering that
+        # vLLM/Mistral accept after a tool turn). No locking needed — Textual's
+        # event loop is single-threaded asyncio, same loop the agent runs on.
+        self._pending_user_injections: list[str] = []
+
         # Shared read-file state — used by write_file / search_replace to
         # enforce Read-before-Write (per Claude Code's tool contract) and
         # by read_file to dedup unchanged-mtime re-reads. Keyed by resolved
@@ -305,6 +314,38 @@ class AgentLoop:
     def auto_approve(self) -> bool:
         return self.config.auto_approve
 
+    def queue_user_injection(self, text: str) -> None:
+        """Queue a user message to be folded into context at the next turn boundary.
+
+        Called by the TUI when the user submits a message while the agent is
+        already running. The injection is drained at the top of the next
+        per-turn iteration in `act()` and surfaced to the model as a SYSTEM
+        note on the last tool result so message ordering stays valid for
+        vLLM/Mistral.
+        """
+        cleaned = (text or "").strip()
+        if cleaned:
+            self._pending_user_injections.append(cleaned)
+
+    def _drain_user_injections(self) -> None:
+        """Pull any queued user messages into the current turn's context.
+
+        Folds them onto the last tool result via the same safe path as
+        `_inject_system_note` — never appends a fresh user-after-tool
+        message, which vLLM/Mistral reject.
+        """
+        if not self._pending_user_injections:
+            return
+        # Snapshot + clear so a concurrent queue append doesn't double-fire.
+        injections = self._pending_user_injections
+        self._pending_user_injections = []
+        for text in injections:
+            note = (
+                f"USER (typed while you were working — fold this into "
+                f"the current task; do not start over):\n{text}"
+            )
+            self._inject_system_note(note)
+
     def set_tool_permission(
         self, tool_name: str, permission: ToolPermission, save_permanently: bool = False
     ) -> None:
@@ -738,6 +779,10 @@ class AgentLoop:
             _prompt_start = time.perf_counter()
             logger.warning("[TIMING] entering conversation while loop")
             while not should_break_loop:
+                # Drain any user messages typed while the agent was working.
+                # Done BEFORE the turn counter increments and BEFORE middleware
+                # runs so the new context is visible to both.
+                self._drain_user_injections()
                 # Loop protection: prevent infinite tool-call loops
                 tool_turns += 1
                 _wt0 = time.perf_counter()
@@ -2999,12 +3044,16 @@ class AgentLoop:
         # appear many times in sequence when building multi-file projects.
         # Record a hot-combo on the stuck tool with an empty-path marker
         # so the per-tool mute in _chat will remove it for 1 turn.
-        _productive_tools = {"write_file", "search_replace", "bash", "run_command"}
-        _check_1a_threshold = 8 if (tool_names and tool_names[-1] in _productive_tools) else 4
-        if len(tool_names) >= _check_1a_threshold:
-            last_n = tool_names[-_check_1a_threshold:]
-            if all(n == last_n[-1] for n in last_n):
-                self._hot_tool_path = (last_n[-1], "<stuck>")
+        # Uniform threshold=8. The autonomous_review fix that lowered this to
+        # 4 for exploration tools (grep/read_file/glob) addressed a misattributed
+        # `harness:thinking_stall` signal — that pattern is about post-thinking
+        # empty messages, handled by the empty-message nudge elsewhere — and the
+        # lowered threshold broke loop_detection regression tests (4 different
+        # greps or read_files is legitimate investigation, not a stuck loop).
+        if len(tool_names) >= 8:
+            last8 = tool_names[-8:]
+            if all(n == last8[-1] for n in last8):
+                self._hot_tool_path = (last8[-1], "<stuck>")
                 return "FORCE_STOP"
 
         # Check 1c: High recent-error fraction. If ≥6 of last 10 tool

{drydock_cli-2.8.17 → drydock_cli-2.8.19}/pyproject.toml

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