drydock-cli 2.8.18__tar.gz → 2.8.20__tar.gz

drydock_cli-2.8.20/.auto_release.lock

@@ -0,0 +1 @@
+836886

{drydock_cli-2.8.18 → drydock_cli-2.8.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.8.18
+Version: 2.8.20
 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,8 @@ 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).
+- **Curiosity Layer**: Engineered intellectual drive (SOVEREIGN_PRD §5.7). Auto-prefetches GraphRAG evidence before the first LLM turn so models retrieve before asserting; detects unfamiliar terms in every user message and enqueues them as learning signals; surfaces a learning queue via `/curiosity`; HLE failures and tool-result surprises automatically feed the queue. `autonomous_review` consumes top items per tick to ship corpus/prompt updates.
 - **Safety First**: Tool execution approval with `--dangerously-skip-permissions` for full auto-approve.
 
 ### Built-in Agents
@@ -379,13 +380,89 @@ 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/`.
+
+### Curiosity Layer
+
+DryDock has an engineered curiosity subsystem (SOVEREIGN_PRD §5.7) that turns "investigate before asserting" from a prompt suggestion into a structural feature:
+
+- **Auto-retrieve before first turn**: when a project has a GraphRAG index at `~/.drydock/graphrag.sqlite`, every user message triggers a retrieve pass; high-quality hits get injected as a synthetic tool result before the LLM sees the message. Opt out with `DRYDOCK_AUTO_RETRIEVE=0`.
+- **Gap detection**: every user message also runs through a heuristic that extracts candidate unfamiliar terms (paper titles, library names, dotted identifiers, ALL-CAPS acronyms, snake_case symbols, versioned packages, filesystem paths). Each becomes an `UNKNOWN_TERM` entry in the learning queue.
+- **Surprise scoring**: when a tool result contradicts a confident assistant claim (e.g. "all tests pass" right before a Traceback), the conflict is logged as `EVIDENCE_CONFLICT` for review.
+- **HLE feedback**: every failed HLE answer auto-enqueues an `HLE_FAILURE` item — the eval becomes a learning signal, not just a scoreboard.
+
+Inspect from the TUI:
+
 ```
+/curiosity            # counts by kind: HLE_FAILURE, EVIDENCE_CONFLICT, UNKNOWN_TERM, IDLE_EXPLORATION
+/curiosity top 5      # top 5 highest-priority pending items
+/curiosity consume <fingerprint>   # mark an item handled
+```
+
+Or from the shell:
+
+```
+python -m drydock.curiosity stats
+python -m drydock.curiosity top --limit 10
+```
+
+The queue lives at `~/.drydock/dispatch/curiosity.jsonl`. `autonomous_review` (cron-launched every 30 min) reads the top items and ships corpus ingests, prompt rules, or AGENTS.md hints from them, tagging commits with `addresses curiosity:<id>:`.
+
+Disable the entire layer with `DRYDOCK_CURIOSITY=0`.
 
 ## Testing
 

{drydock_cli-2.8.18 → drydock_cli-2.8.20}/README.md

@@ -229,7 +229,8 @@ 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).
+- **Curiosity Layer**: Engineered intellectual drive (SOVEREIGN_PRD §5.7). Auto-prefetches GraphRAG evidence before the first LLM turn so models retrieve before asserting; detects unfamiliar terms in every user message and enqueues them as learning signals; surfaces a learning queue via `/curiosity`; HLE failures and tool-result surprises automatically feed the queue. `autonomous_review` consumes top items per tick to ship corpus/prompt updates.
 - **Safety First**: Tool execution approval with `--dangerously-skip-permissions` for full auto-approve.
 
 ### Built-in Agents
@@ -324,13 +325,89 @@ 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/`.
+
+### Curiosity Layer
+
+DryDock has an engineered curiosity subsystem (SOVEREIGN_PRD §5.7) that turns "investigate before asserting" from a prompt suggestion into a structural feature:
+
+- **Auto-retrieve before first turn**: when a project has a GraphRAG index at `~/.drydock/graphrag.sqlite`, every user message triggers a retrieve pass; high-quality hits get injected as a synthetic tool result before the LLM sees the message. Opt out with `DRYDOCK_AUTO_RETRIEVE=0`.
+- **Gap detection**: every user message also runs through a heuristic that extracts candidate unfamiliar terms (paper titles, library names, dotted identifiers, ALL-CAPS acronyms, snake_case symbols, versioned packages, filesystem paths). Each becomes an `UNKNOWN_TERM` entry in the learning queue.
+- **Surprise scoring**: when a tool result contradicts a confident assistant claim (e.g. "all tests pass" right before a Traceback), the conflict is logged as `EVIDENCE_CONFLICT` for review.
+- **HLE feedback**: every failed HLE answer auto-enqueues an `HLE_FAILURE` item — the eval becomes a learning signal, not just a scoreboard.
+
+Inspect from the TUI:
+
 ```
+/curiosity            # counts by kind: HLE_FAILURE, EVIDENCE_CONFLICT, UNKNOWN_TERM, IDLE_EXPLORATION
+/curiosity top 5      # top 5 highest-priority pending items
+/curiosity consume <fingerprint>   # mark an item handled
+```
+
+Or from the shell:
+
+```
+python -m drydock.curiosity stats
+python -m drydock.curiosity top --limit 10
+```
+
+The queue lives at `~/.drydock/dispatch/curiosity.jsonl`. `autonomous_review` (cron-launched every 30 min) reads the top items and ships corpus ingests, prompt rules, or AGENTS.md hints from them, tagging commits with `addresses curiosity:<id>:`.
+
+Disable the entire layer with `DRYDOCK_CURIOSITY=0`.
 
 ## Testing
 

{drydock_cli-2.8.18 → drydock_cli-2.8.20}/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,166 @@ 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.
+
+**Implementation plan (tiered for ROI per engineering hour):**
+
+### Tier 1 — prompt-level + signal plumbing — *shipped 2026-05-12 (v2.8.20)*
+
+The cheapest, highest-leverage cut. Lands the §5.7 directive as
+observable model behavior and starts populating the queue immediately
+without waiting on consumer infrastructure.
+
+- ✅ `drydock.curiosity` module — `CuriosityItem` + `CuriosityKind`
+  enum, append-only JSONL queue at `~/.drydock/dispatch/curiosity.jsonl`
+  with 7-day fingerprint dedup, `detect_gaps()` heuristic extractor for
+  unfamiliar-term candidates, `score_surprise()` across three evidence
+  kinds (judge_verdict, retrieve, tool_result)
+- ✅ Prompt directive in `gemma4.md` — six lines telling the model its
+  default posture is "investigate, then assert": first tool call on a
+  named-thing user message is `retrieve`, prefer evidence on conflict,
+  investigate before asking for clarification
+- ✅ HLE → curiosity feedback loop — `scripts/hle_eval.py` enqueues a
+  `CuriosityItem` on every NO outcome (kind=`HLE_FAILURE`, high
+  confidence when `method=empty` — the GraphRAG-underused failure
+  mode), so every eval run produces ≥10 learning signals
+- ✅ 26 unit tests in `tests/test_curiosity.py` added to the deploy gate
+
+### Tier 2 — consumer side + forcing function — *next week*
+
+The prompt rule alone gets the model to retrieve more, but Gemma 4 will
+still default to prior under context pressure (per
+`project_graphrag_underused.md`). Tier 2 closes that gap and starts
+shipping fixes from the queue.
+
+- ▢ `agent_loop.py` first-turn hook — call `detect_gaps(user_msg)`
+  before the first LLM call; if any candidates returned, automatically
+  invoke `retrieve` on the top 2–3 and inject results onto the user
+  message as `[CURIOSITY PREFETCH]` context. Forces evidence into the
+  window before the model can answer from prior. ~40 lines.
+- ▢ `autonomous_review.sh` curiosity consumer — read
+  `~/.drydock/dispatch/curiosity.jsonl`, pick highest-confidence
+  unconsumed item, generate a fix proposal (AGENTS.md hint / prompt
+  rule / GraphRAG ingest plan), commit with subject prefix
+  `addresses curiosity:<fingerprint>:`. Mirrors the existing harness
+  bucket consumer. ~80 lines.
+- ▢ Surprise-on-tool-result scoring inside `_handle_tool_response` —
+  when `score_surprise()` exceeds threshold, enqueue an
+  `EVIDENCE_CONFLICT` item automatically. Catches confident-but-wrong
+  claims without operator priming.
+- ▢ HLE re-run with the tier-1 prompt to measure adherence — the
+  `retrieve called on ≥80% of HLE Q` criterion needs an actual
+  measurement to confirm the prompt rule moves the needle.
+
+### Tier 3 — Phase 3 proper — *after Deep Noir vectors land*
+
+The advanced layer that depends on infrastructure not yet in place.
+
+- ▢ Deep Noir "exploration" mode vector candidate — train from
+  curiosity-log traces (retrieve calls, hypothesis enumeration,
+  reading-before-writing). Becomes the steerable behavioral prior
+  for curiosity once `drydock.steering` has real vectors.
+- ▢ Idle-cycle exploration worker — when drydock is idle > N minutes
+  and the classifier dispatch queues are non-empty, run one bounded
+  exploratory cycle (pick highest-priority pattern, ingest fresh logs,
+  generate hypothesis, log to `~/.drydock/curiosity_log.md`). Bounded
+  by a tokens-per-day budget so curiosity does not starve user work.
+- ▢ Frustration / surprise detection across the full session, not
+  just single turns — when the operator repeatedly redirects on the
+  same topic, treat it as a high-confidence curiosity signal even if
+  no individual turn tripped the per-turn detectors.
+
+---
+
 # 6. Adaptive Failure Logic
 
 ```text
@@ -383,6 +546,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 +726,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.18 → drydock_cli-2.8.20}/drydock/cli/commands.py

@@ -134,6 +134,13 @@ class CommandRegistry:
                             "/mcp remove <name> | /mcp examples).",
                 handler="_mcp_command",
             ),
+            "curiosity": Command(
+                aliases=frozenset(["/curiosity"]),
+                description="Inspect the curiosity learning queue "
+                            "(usage: /curiosity | /curiosity top | "
+                            "/curiosity stats | /curiosity consume <id>).",
+                handler="_curiosity_command",
+            ),
         }
 
         for command in excluded_commands:

{drydock_cli-2.8.18 → drydock_cli-2.8.20}/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
 
@@ -1465,7 +1491,7 @@ class DrydockApp(App):  # noqa: PLR0904
     async def _mcp_command(self, args: str = "") -> None:
         """Configure MCP servers in ~/.drydock/config.toml."""
         import shlex
-        import tomli
+        import tomllib
         import tomli_w
 
         config_path = Path.home() / ".drydock" / "config.toml"
@@ -1475,7 +1501,7 @@ class DrydockApp(App):  # noqa: PLR0904
             if not config_path.exists():
                 return {}
             try:
-                return tomli.loads(config_path.read_text())
+                return tomllib.loads(config_path.read_text())
             except Exception:
                 return {}
 
@@ -1632,6 +1658,112 @@ class DrydockApp(App):  # noqa: PLR0904
             "remove <name> | examples}`"
         ))
 
+    async def _curiosity_command(self, args: str = "") -> None:
+        """Inspect the curiosity learning queue (SOVEREIGN_PRD §5.7)."""
+        try:
+            from drydock.curiosity.queue import queue_path, read_recent
+            from drydock.curiosity.__main__ import (
+                _KIND_PRIORITY, _load_consumed,
+            )
+        except Exception as e:
+            await self._mount_and_scroll(
+                UserCommandMessage(f"Curiosity module unavailable: {e}")
+            )
+            return
+
+        parts = args.strip().split(None, 1)
+        sub = parts[0].lower() if parts else "stats"
+        rest = parts[1].strip() if len(parts) > 1 else ""
+
+        consumed = _load_consumed()
+        items = list(reversed(read_recent(limit=10_000)))
+        pending = [i for i in items if i.get("id") not in consumed]
+
+        if sub in ("", "stats", "status"):
+            if not items:
+                await self._mount_and_scroll(UserCommandMessage(
+                    f"### Curiosity queue\n\n_Empty._\n\n"
+                    f"Queue: `{queue_path()}`\n\n"
+                    "Items land here when the agent detects unfamiliar terms "
+                    "(SOVEREIGN_PRD §5.7), when tool results contradict the "
+                    "model's assertions, or when an HLE answer scores NO. "
+                    "`autonomous_review` consumes the top items per tick."
+                ))
+                return
+            by_kind: dict[str, dict[str, int]] = {}
+            for it in items:
+                k = it.get("kind", "?")
+                b = by_kind.setdefault(k, {"total": 0, "pending": 0})
+                b["total"] += 1
+                if it.get("id") not in consumed:
+                    b["pending"] += 1
+            lines = [
+                "### Curiosity queue",
+                "",
+                f"Queue: `{queue_path()}`",
+                f"Total: **{len(items)}** items "
+                f"({len(pending)} pending, {len(consumed)} consumed)",
+                "",
+                "| kind | total | pending |",
+                "|---|---:|---:|",
+            ]
+            for k in sorted(by_kind, key=lambda x: _KIND_PRIORITY.get(x, 99)):
+                b = by_kind[k]
+                lines.append(f"| `{k}` | {b['total']} | {b['pending']} |")
+            lines.append("")
+            lines.append("`/curiosity top` for the highest-priority pending items.")
+            await self._mount_and_scroll(UserCommandMessage("\n".join(lines)))
+            return
+
+        if sub == "top":
+            limit = 5
+            if rest.isdigit():
+                limit = max(1, min(20, int(rest)))
+            ranked = sorted(pending, key=lambda x: (
+                _KIND_PRIORITY.get(x.get("kind", ""), 99),
+                -float(x.get("confidence", 0.0)),
+                x.get("ts", ""),
+            ))[:limit]
+            if not ranked:
+                await self._mount_and_scroll(UserCommandMessage(
+                    "_No pending curiosity items._"
+                ))
+                return
+            lines = [f"### Top {len(ranked)} pending curiosity items", ""]
+            for i, it in enumerate(ranked, 1):
+                term = it.get("term", "")[:140]
+                ctx = it.get("context", "")[:200].replace("\n", " ")
+                fp = it.get("id", "?")
+                kind = it.get("kind", "?")
+                conf = it.get("confidence", 0.0)
+                lines.append(
+                    f"**{i}. `{kind}`** · conf={conf} · `{fp}`"
+                )
+                lines.append(f"- term: {term}")
+                if ctx:
+                    lines.append(f"- context: {ctx}")
+                lines.append("")
+            await self._mount_and_scroll(UserCommandMessage("\n".join(lines)))
+            return
+
+        if sub == "consume":
+            if not rest:
+                await self._mount_and_scroll(UserCommandMessage(
+                    "Usage: `/curiosity consume <fingerprint>`"
+                ))
+                return
+            consumed.add(rest)
+            from drydock.curiosity.__main__ import _save_consumed
+            _save_consumed(consumed)
+            await self._mount_and_scroll(UserCommandMessage(
+                f"Marked `{rest}` consumed. Total: {len(consumed)}."
+            ))
+            return
+
+        await self._mount_and_scroll(UserCommandMessage(
+            "Usage: `/curiosity {stats | top [N] | consume <id>}`"
+        ))
+
     async def _admiral_apply_command(self, args: str = "") -> None:
         """Merge an Admiral-staged proposal branch into main."""
         import subprocess