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

drydock_cli-2.8.21/.auto_release.lock

@@ -0,0 +1 @@
+933241

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.8.19
+Version: 2.8.21
 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
@@ -285,6 +285,7 @@ First run creates a config at `~/.drydock/config.toml` and prompts for your prov
 - **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 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
@@ -435,6 +436,34 @@ 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 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.19 → drydock_cli-2.8.21}/README.md

@@ -230,6 +230,7 @@ First run creates a config at `~/.drydock/config.toml` and prompts for your prov
 - **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 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
@@ -380,6 +381,34 @@ 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 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.19 → drydock_cli-2.8.21}/SOVEREIGN_PRD.md

@@ -457,6 +457,73 @@ candidate + tool wiring):**
   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

{drydock_cli-2.8.19 → drydock_cli-2.8.21}/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.19 → drydock_cli-2.8.21}/drydock/cli/textual_ui/app.py

@@ -1658,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

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

@@ -747,15 +747,29 @@ class AgentLoop:
         # as a system note BEFORE the first LLM call. Zero behavior change
         # when the index has nothing relevant; pure lift when it does.
         #
-        # Env-gated via DRYDOCK_AUTO_RETRIEVE so existing workflows are
-        # unaffected. Set to "1" or "true" to enable.
-        if os.environ.get("DRYDOCK_AUTO_RETRIEVE", "").strip().lower() in ("1", "true", "yes"):
+        # SOVEREIGN_PRD §5.7 acceptance #1: "retrieve called on ≥80% of HLE
+        # questions before any content token". Default ON now — the
+        # prefetch is a no-op when no GraphRAG db exists (early return),
+        # so users without a corpus are unaffected. Opt out with
+        # DRYDOCK_AUTO_RETRIEVE=0.
+        if os.environ.get("DRYDOCK_AUTO_RETRIEVE", "1").strip().lower() not in ("0", "false", "no"):
             logger.warning("[AUTO-RETRIEVE] hook entry, query=%r", (user_msg or "")[:80])
             try:
                 self._auto_prefetch_retrieve(user_msg)
             except Exception as _e:
                 logger.warning("auto-prefetch retrieve failed (skipped): %s", _e, exc_info=True)
 
+        # === CURIOSITY GAP LOGGING ===
+        # SOVEREIGN_PRD §5.7 tier-2: extract candidate unfamiliar terms from
+        # the user message and enqueue UNKNOWN_TERM curiosity items. The
+        # queue is dedup'd by fingerprint over 7 days so the same recurring
+        # term doesn't flood it. Disabled by setting DRYDOCK_CURIOSITY=0.
+        if os.environ.get("DRYDOCK_CURIOSITY", "1").strip().lower() not in ("0", "false", "no"):
+            try:
+                self._log_curiosity_gaps(user_msg)
+            except Exception as _e:
+                logger.warning("curiosity gap logging failed (skipped): %s", _e)
+
         try:
             should_break_loop = False
             tool_turns = 0
@@ -1965,6 +1979,65 @@ class AgentLoop:
             result=result,
         )
 
+        # === CURIOSITY: SURPRISE-ON-TOOL-RESULT ===
+        # SOVEREIGN_PRD §5.7: when a tool result contradicts a confident
+        # assertion the model just made (e.g., "All tests pass" right before
+        # a Traceback), score the surprise and enqueue an EVIDENCE_CONFLICT
+        # item for autonomous_review. Gated by DRYDOCK_CURIOSITY=1 (default).
+        if status == "failure" and os.environ.get(
+            "DRYDOCK_CURIOSITY", "1"
+        ).strip().lower() not in ("0", "false", "no"):
+            try:
+                self._maybe_log_surprise(tool_call, text)
+            except Exception as _e:
+                logger.debug("surprise scoring skipped: %s", _e)
+
+    def _maybe_log_surprise(self, tool_call: Any, tool_text: str) -> None:
+        """Score the last assistant assertion against this tool result;
+        enqueue an EVIDENCE_CONFLICT curiosity item if surprise is high."""
+        try:
+            from drydock.curiosity import (
+                CuriosityItem, CuriosityKind, enqueue, score_surprise,
+            )
+            from drydock.curiosity.surprise import SURPRISE_THRESHOLD
+        except Exception:
+            return
+
+        # Walk backward to find the most recent assistant CONTENT (not a
+        # bare tool-call message). That's the assertion to compare against.
+        prior_assertion = ""
+        for msg in reversed(self.messages):
+            if msg.role == Role.assistant and (msg.content or "").strip():
+                prior_assertion = (msg.content or "").strip()
+                break
+        if not prior_assertion:
+            return
+
+        score = score_surprise(prior_assertion, tool_text, kind="tool_result")
+        if score < SURPRISE_THRESHOLD:
+            return
+
+        tool_name = ""
+        try:
+            tool_name = getattr(tool_call.function, "name", "") or ""
+        except Exception:
+            pass
+
+        enqueue(CuriosityItem(
+            kind=CuriosityKind.EVIDENCE_CONFLICT,
+            term=f"{tool_name} contradicted assistant claim",
+            context=(
+                f"Assistant said: {prior_assertion[:200]}\n"
+                f"Tool {tool_name} returned: {tool_text[:200]}"
+            ),
+            source=f"session:{getattr(self, 'session_id', '?')}",
+            suggested_action=(
+                "Investigate whether this is a recurring model bias; "
+                "consider a one-line AGENTS.md hint or sharpened prompt rule."
+            ),
+            confidence=float(score),
+        ))
+
     # _build_repetition_nudge REMOVED (2026-04-13): advisory nudges had
     # 0% effect on Gemma 4 — fired 4 times while model made 8 identical
     # calls. Replaced by token-level sampling bumps (see agent_loop's
@@ -3209,6 +3282,38 @@ class AgentLoop:
 
         return None
 
+    def _log_curiosity_gaps(self, user_msg: str) -> None:
+        """Detect unfamiliar-term candidates in the user message and enqueue
+        them as UNKNOWN_TERM curiosity items.
+
+        Best-effort: any exception is caught at the call site so a curiosity
+        failure never breaks a real user turn. Dedup is handled inside the
+        queue (7-day fingerprint window), so calling this on every user
+        message is safe.
+        """
+        try:
+            from drydock.curiosity import (
+                CuriosityItem, CuriosityKind, detect_gaps, enqueue,
+            )
+        except Exception:
+            return  # module not installed (e.g. minimal test env)
+        gaps = detect_gaps(user_msg or "")
+        if not gaps:
+            return
+        session_src = f"session:{getattr(self, 'session_id', '?')}"
+        for term in gaps:
+            enqueue(CuriosityItem(
+                kind=CuriosityKind.UNKNOWN_TERM,
+                term=term,
+                context=(user_msg or "")[:300],
+                source=session_src,
+                suggested_action=(
+                    "Check whether the project's GraphRAG corpus covers "
+                    f"`{term[:80]}`; if not, ingest the relevant path."
+                ),
+                confidence=0.7,
+            ))
+
     def _auto_prefetch_retrieve(self, user_msg: str) -> None:
         """Auto-fetch relevant chunks from GraphRAG and inject as system note.
 

{drydock_cli-2.8.19 → drydock_cli-2.8.21}/drydock/core/prompts/gemma4.md

@@ -2,10 +2,24 @@ You are DryDock, a CLI coding agent. You write code, fix bugs, and build project
 
 ACT IMMEDIATELY. Your FIRST response must be a tool call — not text. Do NOT explain, plan, or ask. Call a tool NOW.
 
+When answering a direct factual or math question (not writing code), you MUST write visible text — never produce a response with only thinking tokens and no visible content. End your response with "FINAL ANSWER: <your answer>" on its own line so the judge can extract it.
+
 Your tools: read_file, write_file, search_replace, grep, glob, bash, task, web_search, web_fetch, retrieve.
 
+CURIOSITY — default posture is "investigate, then assert" (SOVEREIGN_PRD §5.7):
+- If the user message names a thing you don't have context for (paper title,
+  library, API, identifier, project-specific term), your FIRST tool call is
+  `retrieve(query="<the term>")`. Not text. Not web_search. Retrieve.
+- "I think it's X" is not an answer when retrieve costs one tool call. Look it up.
+- When retrieved evidence contradicts what you were about to say, prefer the
+  evidence and say so. Don't quietly drop the contradiction.
+- Don't ask the user to clarify before you've tried one investigation pass.
+  Read the obvious files; retrieve the obvious terms; ask only if both come up empty.
+
 WHEN TO USE retrieve (project's GraphRAG index):
 - BEFORE editing a file you haven't read in an unfamiliar codebase
+- BEFORE answering a general-knowledge question that names a specific entity —
+  retrieve first; web_search only if retrieve returns low confidence
 - "Where is <Class> defined?" — `retrieve(query="ClassName")` returns the definition site directly
 - Cross-package symbol lookup: parent classes in OTHER packages are indexed too (a `is_json` defined on werkzeug's `Request` shows up when looking up Flask's `Request`)
 - "What does the project doc say about X?" — `retrieve(query="<topic>")` searches markdown / READMEs / PRDs

{drydock_cli-2.8.19 → drydock_cli-2.8.21}/drydock/core/tools/builtins/mcp_resources.py

@@ -83,13 +83,13 @@ class ListMcpResources(
                         tasks.append(list_resources_http(
                             srv.url,
                             headers=srv.headers,
-                            startup_timeout_sec=srv.startup_timeout_seconds,
+                            startup_timeout_sec=srv.startup_timeout_sec,
                         ))
                     elif isinstance(srv, MCPStdio):
                         tasks.append(list_resources_stdio(
                             srv.command,
                             env=srv.env,
-                            startup_timeout_sec=srv.startup_timeout_seconds,
+                            startup_timeout_sec=srv.startup_timeout_sec,
                         ))
 
                 if tasks:
@@ -167,13 +167,13 @@ class ReadMcpResource(
                     content = await read_resource_http(
                         srv.url, args.uri,
                         headers=srv.headers,
-                        startup_timeout_sec=srv.startup_timeout_seconds,
+                        startup_timeout_sec=srv.startup_timeout_sec,
                     )
                 elif isinstance(srv, MCPStdio):
                     content = await read_resource_stdio(
                         srv.command, args.uri,
                         env=srv.env,
-                        startup_timeout_sec=srv.startup_timeout_seconds,
+                        startup_timeout_sec=srv.startup_timeout_sec,
                     )
                 else:
                     continue

drydock_cli-2.8.21/drydock/curiosity/__init__.py

@@ -0,0 +1,40 @@
+"""Curiosity Layer — engineered intellectual drive for drydock.
+
+This module turns the SOVEREIGN_PRD §5.7 directive ("when you notice a gap,
+you close it; when you encounter something unfamiliar, you investigate
+before asserting") into observable signals + a feedback queue.
+
+The classifier framework in `drydock.core.classifier` covers FAILURE
+signals routed to fix-this-thing handlers. Curiosity is the complement:
+LEARNING signals — gaps, surprises, and idle-exploration candidates that
+deserve attention even when nothing has technically failed.
+
+Public surface:
+
+    from drydock.curiosity import (
+        CuriosityItem, CuriosityKind,
+        detect_gaps, score_surprise,
+        enqueue, queue_path,
+    )
+
+Phase 1 (now): gap detection, surprise scoring stub, JSONL queue.
+Phase 2 (next): consumer hook in autonomous_review.sh, retrieve auto-prefetch
+                in agent_loop, system-prompt directive (already in gemma4.md).
+Phase 3 (later): Deep Noir "exploration" vector candidate, idle-cycle worker.
+"""
+from __future__ import annotations
+
+from drydock.curiosity.item import CuriosityItem, CuriosityKind
+from drydock.curiosity.queue import enqueue, queue_path, read_recent
+from drydock.curiosity.gap_detector import detect_gaps
+from drydock.curiosity.surprise import score_surprise
+
+__all__ = [
+    "CuriosityItem",
+    "CuriosityKind",
+    "detect_gaps",
+    "score_surprise",
+    "enqueue",
+    "queue_path",
+    "read_recent",
+]