drydock-cli 2.8.23__tar.gz → 2.8.25__tar.gz

drydock_cli-2.8.25/.auto_release.lock

@@ -0,0 +1 @@
+1115561

drydock_cli-2.8.25/DRYDOCK.md

@@ -0,0 +1,149 @@
+# DRYDOCK.md — harness instructions
+
+Auto-loaded into the system prompt when DryDock runs in this directory.
+Equivalent of `CLAUDE.md` for Claude Code: the per-project instructions
+file the model reads on every session. Keep it short — every byte here
+costs context budget on every turn.
+
+## What DryDock is
+
+A local-first CLI coding agent with a TUI. Talks to any
+OpenAI-compatible local model server (vLLM, llama.cpp, Ollama,
+LM Studio). Production target: Gemma 4 26B-A4B-it on a 2-GPU
+workstation. The agent loop, classifier, Curiosity Layer, GraphRAG
+hook, Admiral supervisor, and tool plugins all live in `drydock/core/`.
+
+The harness is the product. When something goes wrong, fix the
+harness — don't work around it in a script.
+
+## Four core principles (your default posture)
+
+1. Don't assume. Don't hide confusion. Surface tradeoffs.
+2. Minimum code that solves the problem. Nothing speculative.
+3. Touch only what you must. Clean up only your own mess.
+4. Define success criteria. Loop until verified.
+
+## Tool inventory — when to use each
+
+**Always-available reads:** `read_file`, `glob`, `grep`, `retrieve` (GraphRAG),
+`web_search`, `web_fetch`. Auto-approved.
+
+**Writes (gate-able):** `write_file`, `search_replace`, `bash`, `notebook_edit`.
+
+**Direct built-ins for transformer weaknesses (USE THESE — don't compute in your head):**
+
+- `math(expression="...")` — exact arithmetic via Python stdlib (`math.factorial(20)`,
+  `math.comb(50, 5)`, `Fraction(1,3) + Fraction(1,6)`,
+  `statistics.mean([...])`). USE for any non-trivial number.
+- `count(pattern="...", text=... OR path=..., mode=...)` — exact substring /
+  regex / lines / words / chars / bytes counter. USE instead of estimating
+  "how many".
+- `memory(op="save"|"recall"|"list_keys"|"forget"|"stats", ...)` — persistent
+  cross-session notes at `~/.drydock/agent_memory/notes.jsonl`. SAVE
+  per-project patterns and decisions; RECALL them next session.
+- `verify(criterion="...", command="...", expect="...", expect_mode=...)` —
+  programmatic success check after a change. Operationalizes principle #4
+  ("Loop until verified").
+
+**Curiosity Layer (PRD §5.7) — your default posture is "investigate, then assert":**
+
+- If the user message names an unfamiliar entity (paper, library, API,
+  identifier), 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.
+- When retrieved evidence contradicts what you were about to say,
+  prefer the evidence and say so. Don't quietly drop the contradiction.
+
+**Subagent delegation:** Only for genuinely large tasks (9+ files, multiple
+subdirs). For 1-8 files BUILD INLINE — wasted delegation costs 60-90s of
+extra context loading.
+
+## Critical constraints
+
+- **Loop detection is advisory.** It NEVER stops you — only nudges and
+  prunes duplicate calls. The only hard stop is `MAX_TOOL_TURNS = 200`.
+- **No `--no-verify` git commits, no `pkill drydock`** (kills the user's TUI).
+- **TUI only.** Headless mode was removed deliberately. All testing
+  goes through the real TUI via `pexpect` (see `scripts/shakedown.py`).
+- **Don't `git push` from this repo** — local and origin diverge by design;
+  `auto_release.sh` rebuilds and pushes every 6h. Direct edits to
+  `site-packages/` get overwritten at the next cron tick.
+- **Match exact CLI specs in PRDs.** Every subcommand listed must have a
+  working handler — not just argparse registration.
+- **Stub classes are forbidden.** Never write
+  `class X: def method(self): pass` inline to silence ModuleNotFoundError.
+  Write the real class in its own file and import it.
+- **`--help` is not a test.** A package that `--help`s successfully can
+  have broken imports in every other module. Real test = a
+  `functional_tests.sh` that exercises actual feature commands and
+  checks real outputs.
+
+## File map (only the load-bearing pieces)
+
+```
+drydock/
+├── core/
+│   ├── agent_loop.py          ← THE main loop. Loop detection, message
+│   │                             ordering, Curiosity hooks, MTP dispatch
+│   ├── system_prompt.py       ← Loads DRYDOCK.md + gemma4.md/cli.md
+│   ├── tools/
+│   │   ├── manager.py         ← Tool auto-discovery (any non-_ .py here
+│   │   │                         is picked up)
+│   │   └── builtins/          ← read_file, write_file, grep, glob, bash,
+│   │                            retrieve, math, count, memory, verify, ...
+│   ├── classifier/            ← Failure → 5-bucket dispatch (harness /
+│   │                            retrieval / steering / model_prior /
+│   │                            ambiguous_input)
+│   └── prompts/
+│       ├── gemma4.md          ← Compact (50 lines) prompt for Gemma 4
+│       └── cli.md             ← Full prompt for stronger models
+├── curiosity/                 ← SOVEREIGN_PRD §5.7 — gap_detector,
+│                                surprise scorer, JSONL queue, CLI
+├── graphrag/                  ← AST symbol indexer + TF-IDF retriever
+├── steering/                  ← Deep Noir vector framework (scaffolding)
+└── cli/textual_ui/app.py      ← TUI app + slash commands
+
+scripts/
+├── auto_release.sh            ← Cron 0,6,12,18 CDT — bumps version, builds
+│                                wheel, twine upload, GitHub push
+├── deploy_to_github.sh        ← Cron 04:00 CDT — full test gate then sync
+├── autonomous_review.sh       ← Cron */30 — Claude Code drains classifier
+│                                + curiosity queues, ships fixes
+├── shakedown.py               ← The honest test harness (drives real TUI)
+└── bench_inference.py         ← Throughput benchmark vs localhost:8000
+```
+
+## Workflows
+
+**Building from a PRD:**
+
+1. Read the spec.
+2. `write_file` each file. Start with `__init__.py` and `__main__.py`.
+3. Verify package imports: `bash` → `python3 -m <pkg> --help`.
+4. Run a real test: `bash` → exercise actual subcommands; check outputs
+   match the PRD's examples.
+5. If the PRD has a `functional_tests.sh`, run THAT — not just `--help`.
+
+**Fixing a bug:**
+
+1. `grep` for the symbol mentioned.
+2. `read_file` the source.
+3. `search_replace` minimal change.
+4. `verify(criterion="...", command="pytest ...", expect_mode="exit_code", expect="0")`.
+
+**Adding a feature to drydock itself (in this repo):**
+
+1. `git status` first — never destroy uncommitted work.
+2. Make the change, run the relevant test file (`pytest tests/test_X.py -q`).
+3. Commit; let `auto_release.sh` (next 6h tick) ship to PyPI + GitHub.
+4. Don't `git push` — see Constraints.
+
+## When you stop
+
+A turn ends when:
+
+- TODO mode (multi-step request like "build the package"): every item done.
+- SIMPLE mode (single ask): exactly that, then stop. Don't invent
+  follow-up work the user didn't ask for.
+
+NEVER ask "would you like me to proceed". Just do it.

{drydock_cli-2.8.23 → drydock_cli-2.8.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.8.23
+Version: 2.8.25
 Summary: Local-first CLI coding agent — tested with Gemma 4 26B via vLLM
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock

{drydock_cli-2.8.23 → drydock_cli-2.8.25}/SOVEREIGN_PRD.md

@@ -480,49 +480,141 @@ without waiting on consumer infrastructure.
   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*
+### Tier 2 — consumer side + forcing function — *shipped 2026-05-12 (v2.8.20–22)*
 
 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.
+still default to prior under context pressure. Tier 2 closes that gap
+and starts shipping fixes from the queue.
+
+- ✅ `agent_loop.py` curiosity gap-logging hook — every user message
+  runs through `detect_gaps`; each candidate term is enqueued as an
+  `UNKNOWN_TERM` item (gated by `DRYDOCK_CURIOSITY=1`, default on)
+- ✅ `_maybe_log_surprise` in `_handle_tool_response` — fires on tool
+  failures, scores against the most recent assistant assertion, queues
+  `EVIDENCE_CONFLICT` items above the 0.6 threshold. Catches
+  confident-but-wrong claims without operator priming.
+- ✅ Auto-prefetch retrieve hook (`_auto_prefetch_retrieve`) flipped
+  to **default ON** (was env-gated off). Synthetic `retrieve` tool
+  call injected before the first LLM turn whenever the GraphRAG corpus
+  has good hits. Forces evidence into the window — the §5.7
+  acceptance #1 forcing function. Opt out: `DRYDOCK_AUTO_RETRIEVE=0`.
+- ✅ `autonomous_review.sh` curiosity consumer — step 2b in
+  `scripts/autonomous_review_prompt.md` drains the top item per tick,
+  acts on it, marks consumed, prefixes commit with
+  `addresses curiosity:<id>:`.
+- ✅ `python -m drydock.curiosity {top,stats,consume,reset}` CLI.
+- ✅ `/curiosity` slash command for in-TUI inspection.
+- ✅ HLE backfill script — 82 historical HLE_FAILURE items ingested
+  from prior runs so the queue has signal even before fresh runs.
+
+### Tier 3a — operator-visible scaffolding — *shipped 2026-05-12 (v2.8.22)*
+
+- ✅ `scripts/curiosity_idle_cycle.sh` — bounded exploration worker
+  (cron-suggested hourly). Idle-gated (no TUI / no HLE / no
+  autonomous_review), daily-capped at 12 cycles, pause sentinel.
+  Appends hypotheses to `curiosity_log.md`; no model calls.
+- ▢ Wire the idle-cycle script into cron — operator decision; script
+  is checked in and ready.
+
+### Tier 3b — model-shape work — *blocked / future*
 
 - ▢ 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.
+  curiosity-log traces. Blocked on real Deep Noir vectors landing in
+  `drydock.steering`.
+- ▢ Frustration / surprise detection across the full session — pattern:
+  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.
+
+---
+
+## 5.8 Direct built-in tools for transformer weaknesses — shipped 2026-05-12 (v2.8.22–23)
+
+Per the transformer-weakness map (Babich, "What coding can fix"):
+arithmetic, counting, persistent memory, and reliability/verification
+are well-solved by classical code wrapped as agent tools. We ship them
+as direct built-ins (NOT MCP — per Babich, "MCP is Dead", MCP servers
+burn ~20K tokens of context per call, which is a real cost on a
+131K-context local model).
+
+| Tool | Closes | Status |
+| ---- | ------ | ------ |
+| `math(expression="...")` | Arithmetic, factorials, primes, statistics, exact fractions via Python stdlib (math/statistics/Fraction/Decimal) sandbox | ✅ shipped, 37 tests |
+| `count(pattern, text/path, mode)` | "How many X" estimation — substring/regex/lines/words/chars/bytes | ✅ shipped, 23 tests |
+| `memory(op, key, value)` | Long-term cross-session memory at `~/.drydock/agent_memory/notes.jsonl` (save / recall / list_keys / forget / stats) | ✅ shipped, 22 tests |
+| `verify(criterion, command, expect, expect_mode)` | Operationalizes "Loop until verified" — runs a check, returns pass/fail (contains/regex/equals/exit_code/file_exists/file_contains) | ✅ shipped, 24 tests |
+
+Anti-pattern explicitly forbidden: NEVER convert these into MCP
+servers later. The whole point is one direct built-in per closed
+weakness. MCP integration remains available for users who want to
+connect external services, just not for capabilities the harness
+should own.
+
+## 5.9 Project-instructions auto-create (DRYDOCK.md)
+
+Per CLAUDE.md / AGENTS.md convention: every fresh project session
+should land a per-project instructions file the model reads on every
+turn. Best practices: lean (every byte costs context budget), language-
+detected, with TODO stubs the user fills in.
+
+- ✅ `_ensure_drydock_md()` in `agent_loop.py` — runs once on first
+  session. Detects language from manifest (pyproject / package.json /
+  Cargo.toml / go.mod / Gemfile / pom.xml / build.gradle), writes a
+  ~2.8 KB starter with: project overview (auto-detected stack +
+  TODO purpose), tool inventory by purpose (especially the new
+  math/count/memory/verify built-ins the model otherwise overlooks),
+  4 core principles, Curiosity behavior, TODO stubs for Coding
+  Standards / Workflow / External References. 10 unit tests.
+- ✅ `/data3/drydock/DRYDOCK.md` — hand-written canonical for drydock
+  itself, loaded when running drydock from this source tree.
+
+## 5.10 Inference throughput (Multi-Token Prediction investigation)
+
+Investigation 2026-05-12 — outcome: **blocked on llama.cpp upstream**.
+
+- ✅ Baseline measured: **64.1 tok/s** on `gemma-4-26B-A4B-it-UD-Q3_K_M`
+  via llama.cpp 9115 on 2× RTX 4060 Ti, single-GPU `-ngl 99`,
+  `-c 32768`, `-ctk q8_0 -ctv q8_0`.
+- ✅ `scripts/bench_inference.py` — 5-prompt × N-token throughput
+  bench against localhost:8000 for any future MTP / quant / serving
+  comparison.
+- ✅ Trained drafter checkpoints downloaded to `/data3/Models/`
+  (AtomicChat + Radamanthys community quants of the
+  `gemma-4-26B-A4B-it-assistant` model). **Blocked**: both use custom
+  archs `gemma4_assistant` / `gemma4_mtp` that llama.cpp 9115 doesn't
+  recognize. Files ready for when upstream lands the arch.
+- ✅ Built-in ngram-* speculative decoding tested
+  (`--spec-type ngram-simple|ngram-cache|ngram-mod`) — 0% measured
+  speedup on either mixed prompts or code-heavy prompts. The lookup
+  overhead cancels saved forward passes for this 26B MoE shape on
+  TP=2.
+- ▢ vLLM with MTP — untested. The article (Pawel, 2026-05-10) claims
+  day-one vLLM support. Switching back to the `start_gemma4.sh` vLLM
+  path with the bf16 assistant Transformers checkpoint (not GGUF) is
+  the next thing to try.
+- ▢ Quant upgrade Q3_K_M → Q4_K_M — Q4 file downloaded
+  (`gemma-4-26B-A4B-it-UD-Q4_K_M.gguf`, 15.78 GiB), pending validation
+  that it doesn't reintroduce the hallucinated-tool / write-loop
+  failure modes that Q3_K_M was originally selected to suppress.
+  Higher quants (Q5_K_M, Q6_K) require tensor split via `-sm row`.
+
+## 5.11 Bug-report template + dependency audit
+
+Operator-visibility plumbing landed alongside the §5.7 work:
+
+- ✅ `.github/ISSUE_TEMPLATE/bug-report.yml` overhaul — pre-flight
+  checklist, expanded component dropdown (CLI/TUI / ACP / MCP /
+  GraphRAG / Curiosity / Auto-release / Install), required Model +
+  provider field (the #1 missing-info gap on prior bugs), separate
+  OS+Python+install field, expected-vs-actual section, logs section
+  pointed at correct paths.
+- ✅ `.github/ISSUE_TEMPLATE/config.yml` — removed broken upstream
+  links (mistralai/mistral-vibe Discussions, old Mistral docs URL,
+  outdated Discord).
+- ✅ Dependency audit — `requests` removed (0 imports anywhere; `httpx`
+  is the actual HTTP client); `pexpect` moved runtime → dev (only used
+  by harness scripts that don't ship in the wheel). End-user install
+  drops ~1.8 MB. All other suspicious entries verified used.
 
 ---
 

{drydock_cli-2.8.23 → drydock_cli-2.8.25}/drydock/core/agent_loop.py

@@ -417,6 +417,12 @@ class AgentLoop:
         # without it the model loops on ls/bash instead of using subagents.
         if self.stats.steps <= 1:
             self._ensure_agents_md()
+            # Skip DRYDOCK.md auto-create under pytest so tmp_path-based
+            # tests don't get unexpected files appearing in their fixture
+            # dirs. Unit tests for the auto-create function call it
+            # directly (bypassing this gate).
+            if "PYTEST_CURRENT_TEST" not in os.environ:
+                self._ensure_drydock_md()
 
         # Load project state for cross-session context
         try:
@@ -747,12 +753,21 @@ 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.
         #
+        # Disable both hooks under pytest. They'd otherwise inject noise
+        # into the agent's message stream — a synthetic retrieve tool call
+        # for auto-retrieve, and queue writes for curiosity — which breaks
+        # tests that pin the exact event order or count messages.
+        # Set DRYDOCK_AUTO_RETRIEVE=1 / DRYDOCK_CURIOSITY=1 explicitly in a
+        # test if you want to exercise them.
+        _under_pytest = "PYTEST_CURRENT_TEST" in os.environ
+
         # 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),
+        # questions before any content token". Default ON in production —
+        # 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"):
+        _auto_retrieve_default = "0" if _under_pytest else "1"
+        if os.environ.get("DRYDOCK_AUTO_RETRIEVE", _auto_retrieve_default).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)
@@ -764,7 +779,9 @@ class AgentLoop:
         # 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"):
+        # Off by default under pytest (see auto-retrieve note above).
+        _curiosity_default = "0" if _under_pytest else "1"
+        if os.environ.get("DRYDOCK_CURIOSITY", _curiosity_default).strip().lower() not in ("0", "false", "no"):
             try:
                 self._log_curiosity_gaps(user_msg)
             except Exception as _e:
@@ -3584,6 +3601,123 @@ class AgentLoop:
         if parts:
             self._inject_system_note("\n".join(parts))
 
+    def _ensure_drydock_md(self) -> None:
+        """Auto-create DRYDOCK.md in the project root if absent.
+
+        This file is the drydock equivalent of CLAUDE.md / AGENTS.md: a
+        per-project instructions file the model loads on every session
+        (see system_prompt._load_project_instructions, 16 KB cap).
+
+        We write a LEAN starter (~2 KB) telling the model what tools the
+        harness ships with and a few stub sections the user can fill in
+        for project-specific guidance. The point is to give the agent
+        signal about its own capabilities — especially the math / count /
+        memory / verify built-ins it might otherwise overlook — without
+        burning context budget on every turn.
+
+        Best practices baked in:
+        - Detect the language from manifest files (pyproject / package.json /
+          Cargo.toml / go.mod) so the overview line is meaningful.
+        - Tool inventory is one bullet line per category, not a treatise.
+        - Stub sections (Coding Standards, Workflow) marked TODO so the
+          user knows where to add their own rules.
+        """
+        cwd = Path.cwd()
+        if (cwd / "DRYDOCK.md").exists() or (cwd / "drydock.md").exists():
+            return
+
+        # Detect language from manifest presence — single short line.
+        lang = "Unknown stack"
+        for marker, name in (
+            ("pyproject.toml", "Python"),
+            ("setup.py", "Python"),
+            ("requirements.txt", "Python"),
+            ("package.json", "JavaScript / TypeScript"),
+            ("Cargo.toml", "Rust"),
+            ("go.mod", "Go"),
+            ("Gemfile", "Ruby"),
+            ("pom.xml", "Java (Maven)"),
+            ("build.gradle", "Java/Kotlin (Gradle)"),
+        ):
+            if (cwd / marker).exists():
+                lang = name
+                break
+
+        try:
+            (cwd / "DRYDOCK.md").write_text(
+                f"""# DRYDOCK.md — project instructions for the agent
+
+Auto-loaded into the system prompt every session (16 KB cap). Keep it
+lean — every byte costs context budget on every turn. Edit freely; this
+is a living document.
+
+## Project overview
+
+- **Stack:** {lang} _(detected from manifest)_
+- **Purpose:** _(TODO: one sentence on what this project does)_
+- **Entry point:** _(TODO: e.g., `python -m mypkg`, `npm start`, `cargo run`)_
+
+## What the harness can do for you
+
+DryDock ships these direct built-in tools (one entry each in the model's
+tool list — no MCP overhead):
+
+- **Reads / search:** `read_file`, `glob`, `grep`, `retrieve` (GraphRAG
+  semantic search if the project is indexed), `web_search`, `web_fetch`.
+- **Writes:** `write_file`, `search_replace` (preferred for edits),
+  `bash`, `notebook_edit`.
+- **Exact computation (don't compute in your head):**
+  - `math(expression="...")` — sandboxed Python: `math.factorial(20)`,
+    `Fraction(1,3)+Fraction(1,6)`, `statistics.mean([...])`.
+  - `count(pattern="...", text=... OR path=..., mode=...)` —
+    substring / regex / lines / words / chars / bytes.
+- **Persistent memory across sessions:** `memory(op="save"|"recall"|...)`
+  — store and recall key/value notes at `~/.drydock/agent_memory/`.
+- **Verify before claiming done:**
+  `verify(criterion="...", command="...", expect="...", expect_mode="contains")`
+  — runs a check, returns pass/fail. Operationalizes "Loop until
+  verified."
+- **Delegation:** `task(agent="builder"|"explore"|"diagnostic"|"planner",
+  task="...")` — only for genuinely large work (9+ files); inline for
+  smaller.
+
+## Behavioral rules (defaults)
+
+1. Don't assume. Don't hide confusion. Surface tradeoffs.
+2. Minimum code that solves the problem. Nothing speculative.
+3. Touch only what you must. Clean up only your own mess.
+4. Define success criteria. Loop until verified (call `verify`).
+
+When you see an unfamiliar named entity (paper title, library, API,
+identifier), your FIRST tool call is `retrieve(query="<the term>")` —
+not text, not web_search. Investigate before asserting (Curiosity Layer
+default).
+
+## Coding standards
+
+- _(TODO: e.g., "prefer named exports", "tabs not spaces", "no `any` in
+  TypeScript", "snake_case for Python", language-specific rules here)_
+
+## Workflow
+
+- **Build:** _(TODO: e.g., `npm run build`, `cargo build --release`)_
+- **Test:** _(TODO: e.g., `pytest -q`, `npm test`, `cargo test`)_
+- **Run:** _(TODO: e.g., `python -m mypkg`, `npm start`)_
+- **Format/lint:** _(TODO: e.g., `ruff check . && ruff format .`)_
+
+## External references
+
+- _(TODO: link to the project README, design docs, style guide if any)_
+
+---
+_Auto-generated by drydock on first session in this directory. Customize
+or replace freely; future sessions will respect your edits._
+"""
+            )
+            logger.info("Auto-created DRYDOCK.md in %s", cwd)
+        except (OSError, PermissionError):
+            pass  # Non-critical — read-only filesystem
+
     def _ensure_agents_md(self) -> None:
         """Auto-create AGENTS.md if no project instructions file exists.
 

{drydock_cli-2.8.23 → drydock_cli-2.8.25}/pyproject.toml

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

{drydock_cli-2.8.23 → drydock_cli-2.8.25}/scripts/hle_eval.py

@@ -394,10 +394,19 @@ def main() -> int:
     ap.add_argument("--seed", type=int, default=42)
     ap.add_argument("--resume", type=Path,
                     help="resume from existing run dir (skip already-done IDs)")
+    ap.add_argument(
+        "--category", default="",
+        help=(
+            "Filter to questions in this HLE category (case-insensitive "
+            "substring match against q['category']). Examples: 'math', "
+            "'chemistry', 'physics'. Use this to measure tool-impact on a "
+            "specific axis."
+        ),
+    )
     args = ap.parse_args()
 
     print(f"[hle_eval] source={args.source} limit={args.limit} "
-          f"shuffle={args.shuffle}")
+          f"shuffle={args.shuffle} category={args.category or '(any)'}")
 
     if args.source == "seed":
         questions = load_seed()
@@ -405,6 +414,13 @@ def main() -> int:
         questions = load_hle()
 
     print(f"[hle_eval] loaded {len(questions)} questions")
+
+    if args.category:
+        cat = args.category.lower().strip()
+        before = len(questions)
+        questions = [q for q in questions if cat in (q.get("category", "") or "").lower()]
+        print(f"[hle_eval] category filter '{args.category}': {before} → {len(questions)} questions")
+
     if args.shuffle:
         random.Random(args.seed).shuffle(questions)
     questions = questions[: args.limit]