drydock-cli 2.8.27__tar.gz → 2.8.28__tar.gz

drydock_cli-2.8.28/.auto_release.lock

@@ -0,0 +1 @@
+1359290

{drydock_cli-2.8.27 → drydock_cli-2.8.28}/CLAUDE.md

@@ -6,9 +6,18 @@ Drydock is a local CLI coding agent (fork of mistral-vibe, Apache 2.0).
 - **Repo:** https://github.com/fbobe321/drydock
 - **PyPI:** https://pypi.org/project/drydock-cli/ (v2.6.32)
 - **Goal:** Reliable TUI coding agent with local LLMs. PRD-driven project building.
-- **Hardware:** 2x RTX 4060 Ti 16GB, Gemma 4 26B MoE (A4B) via vLLM Docker at localhost:8000
+- **Hardware:** 2x RTX 4060 Ti 16GB, Gemma 4 26B MoE (A4B)
 - **Server:** remus (Ubuntu 22.04, user: bobef)
-- **Active model:** Gemma 4 26B-A4B-it-AWQ-4bit (only 4B active params, ~70 tok/s)
+- **Active model (2026-05-14):** **Gemma-4-26B-A4B-it-UD-Q3_K_M.gguf** via
+  llama.cpp Docker (`ghcr.io/ggml-org/llama.cpp:server-cuda`) on :8000.
+  Q4_K_M was trialed 2026-05-12→14 but rolled back because the
+  quant shift produced no measurable HLE-correctness lift and added
+  ~9% per-token latency. Re-swap to Q4 via
+  `docker stop llamacpp-gemma4 && docker rm llamacpp-gemma4`
+  and a `docker run` with `-m /models/gemma-4-26B-A4B-it-UD-Q4_K_M.gguf`.
+  AWQ-4bit on vLLM is the historical alternate path and stays available
+  via `/data3/Models/start_gemma4.sh` (the vLLM script — NOT the
+  llama.cpp one). Speed: ~64 tok/s e2e on Q3.
 - **The honest test:** `scripts/shakedown_interactive.py` — drives the real TUI
   via pexpect with a multi-step user conversation (24 steps per PRD: plan,
   build, test, add features, debug, review code, edge cases, README).
@@ -23,7 +32,54 @@ Drydock is a local CLI coding agent (fork of mistral-vibe, Apache 2.0).
   testing.
 - **Priority:** TUI experience first. Fix drydock bugs, don't simplify PRDs.
 - **370 PRDs** at /data3/drydock_test_projects/ — the benchmark suite
-- **Current version:** v2.6.32 on PyPI
+- **Current version:** v2.8.27 on PyPI (auto-released every 6h from `main`)
+- **Active continuous loops:** stress harness (hourly), autonomous_review
+  (30-min), classify_pulse (10-min), telegram_bot keepalive (2-min),
+  hle_babysitter (hourly @ :45 — 10-Q math HLE batch per tick, see
+  HLE_PRD §"Continuous HLE evaluation"). Anything new the operator
+  adds should not run at :00 or :30 (autonomous_review owns those).
+
+## Current plan (2026-05-14)
+
+Three vectors moving in parallel. Each has a queue of concrete fixes
+tracked as TaskCreate items; the high-level shape is:
+
+1. **HLE** — keep pushing the floor up from 6.7% on Math. The
+   `scripts/hle_babysitter.sh` cron runs 10-Q Math batches every hour.
+   Open work: rotate categories beyond Math; build a multi-batch
+   aggregator (`scripts/hle_aggregate.py`); produce a clean Q3 vs Q4
+   stall-rate comparison once 30+ Q3 Math attempts have accumulated;
+   verify the gemma4.md tool-inventory change (e47cc4e) actually
+   lifted math/count/memory/verify call rates.
+
+2. **GraphRAG** — the auto-prefetch hook is shipping good chunks on
+   trivia but not on hard symbolic Math. Two concrete moves: lower
+   `QUALITY_THRESHOLD` (currently 8.0 in `agent_loop.py:3391`) once
+   we know the real score distribution, and add an arxiv-corpus
+   fallback (`/data3/arxiv_corpus/graphrag.sqlite`) when the primary
+   index returns nothing above threshold.
+
+3. **Deep Noir** — sidecar/hooks/capture/train all coded; the
+   `apply_chat_template` API-drift fix shipped 2026-05-14 (f02aa4b).
+   Real blocker for v1 vectors: contrastive-pair extraction is
+   currently broken — admiral records full UUIDs (e.g.
+   `5b55aacd-3606-4656-ad4b-eacf86506eda`) but session dirs are named
+   `session_<date>_<time>_<short_uuid>` where the `short_uuid` is the
+   first 8 chars of the SESSION's own UUID, not admiral's recorded
+   one. `extract_pairs._find_session_dir` matches on session_dir name
+   endswith(admiral_short) which only succeeds for the rare case
+   where both happen to match. Yield on `empty_after_tool:bash`:
+   2 / 88 derailed sessions found. Needs a real mapping layer
+   (meta.json → admiral) or admiral has to be fixed to record the
+   short hash used by session dirs.
+
+Operator controls for the continuous loops:
+
+```bash
+touch /data3/drydock/.pause_hle_babysitter      # pause continuous HLE
+touch /data3/drydock_test_projects/.pause_watchdog
+touch /data3/drydock/.pause_auto_release        # pause 6h PyPI publish
+```
 
 ## Build & Test
 

{drydock_cli-2.8.27 → drydock_cli-2.8.28}/DEEP_NOIR_PRD.md

@@ -1,6 +1,38 @@
 # Deep Noir activation-patching PRD — reasoning steering, transformers-backed sidecar
 
-**Status:** Draft, 2026-05-09. Phase 3 of HLE_PRD.
+**Status:** Draft, last updated 2026-05-14. Phase 3 of HLE_PRD.
+
+## 2026-05-14 progress update
+
+- ✅ Milestones 1-4 are coded and unit-test green (91/91 in
+  `tests/test_steering*`).
+- ✅ Sidecar `apply_chat_template` API-drift bug fixed (f02aa4b) +
+  5 dedicated tests against fake tokenizers.
+- ⚠ **Live-GPU smoke deferred.** First attempt 2026-05-13 11:21 UTC
+  loaded the AWQ weights but crashed in `model.generate()` (the bug
+  fixed above). The crashed Python kept ~29 GB of VRAM until manually
+  killed; production Q4 then refused to restart for ~30 seconds. With
+  the fix shipped, the next attempt is expected clean — but needs an
+  operator-approved Q3-stop window.
+- 🚨 **Pair extraction is broken.** `extract_pairs.py` resolves admiral
+  session UUIDs against `~/.vibe/logs/session/session_<date>_<short>`
+  via name-suffix match on the first 8 hex chars of the admiral UUID.
+  This only succeeds when the admiral UUID and the session's own UUID
+  happen to share those 8 chars — they don't, because admiral and
+  session generate UUIDs independently. Yield on
+  `empty_after_tool:bash`: **2 / 88 derailed pairs** found
+  (`/data3/drydock/research/deep_noir/pairs/empty_after_bash.jsonl`,
+  82 total = 2 derailed + 80 good). That's not enough to train a
+  vector. Fix candidates:
+    1. Crawl every session dir's `meta.json`, build a `{full_uuid →
+       dir}` map, look up admiral UUIDs against that map. Highest
+       fidelity. The crawl is one-shot and cacheable.
+    2. Change admiral to record the same short-hash that session dirs
+       use (would require coordinating with `drydock.admiral`).
+  Path 1 is unblocked and surgical; path 2 is bigger surgery for
+  marginal benefit. Default to path 1.
+
+## Next concrete steps
 
 The v0 token-bias path (`LogitBiasSteeringApplier`) hit its expected ceiling: phase1_steered scored 1/20 = 5% on the worked-example seed, identical to the unsteered baseline. This PRD scopes the next-tier applier — real activation patching at a configurable decoder layer — using a `transformers`-backed sidecar process so we can validate the architecture before the bigger vLLM forward-hook port. Goal: get one steering vector to lift Phase 1 above 5/20 on the existing 20-question seed, proving reasoning steering works at all on quantized Gemma 4. Then port to vLLM for production speed.
 

{drydock_cli-2.8.27 → drydock_cli-2.8.28}/HLE_PRD.md

@@ -6,6 +6,89 @@ the dominant cause of thinking-stalls. Deep Noir sidecar wiring (M1-M4)
 is in tree; M1 end-to-end GPU smoke pending after the transformers 5.x
 apply_chat_template fix (f02aa4b).
 
+## HLE was retrieving against the WRONG corpus (fixed edb61c9)
+
+Trace from a Q3 session 2026-05-14: a local-field-theory HLE Math
+question pulled `/data3/drydock_test_projects/403_tool_agent/help_output.txt`
+(score 38.7) as the top retrieve hit. hle_eval.py spawns drydock
+subprocesses that, until now, defaulted to
+`~/.drydock/graphrag.sqlite` — the project corpus full of test
+artifacts — not the arXiv corpus (1.18M chunks, math/physics/CS).
+The Q3-with-AR run effectively had the model answering math
+questions with a tool_agent CLI help page as "evidence."
+
+Fixed in `scripts/hle_babysitter.sh`: every per-batch invocation
+now sets `DRYDOCK_GRAPHRAG_DB=/data3/arxiv_corpus/graphrag.sqlite`
+for the subprocess only. User TUI / stress / other drydock sessions
+still see the project corpus.
+
+Takes effect on the next cron tick after this commit lands —
+shell scripts run from the source tree, not site-packages, so this
+fix is live without waiting for v2.8.28.
+
+## Judge was broken for the entire history (fixed bc12eee)
+
+Audit 2026-05-14: across all 165 HLE results on disk, the judge was
+invoked 22 times and returned **ERROR every single time (100%)**.
+Zero YES verdicts, zero NO verdicts — every judged answer dropped
+to ERROR because `text.splitlines()[0]` raised IndexError on empty
+content (Gemma 4 thinking-budget exhaustion on the judge call,
+emitting only `reasoning_content` with no `content`).
+
+The 5/163 = 3.1% lifetime score came entirely from `exact` (5) and
+`fuzzy` (0) matches — judge YES count was zero. **The real correctness
+rate is unknown until the fix ships.** Q3 Math Q1 today produced
+`e^{-\gamma} \frac{q-1}{h} q^{g-1} \log q` against gold
+`\frac{q^{g-1}(q-1)\log q}{e^\gamma h}` (mathematically identical)
+and got marked ERROR. That alone changes the 0/N batch verdict for
+that session.
+
+Fix in commit `bc12eee` (will ship in v2.8.28):
+- Read `reasoning_content` when `content` is empty
+- Scan the whole response for YES/NO/PARTIAL with word-boundary
+- max_tokens 80 → 200, plus a tighter "one word only" retry
+- ERROR reason now echoes the raw text so failures are diagnosable
+
+**Backfill applied 2026-05-14 01:48 UTC.** Ran
+`scripts/rejudge_hle.py --apply --apply-to-summary` across all 22
+historical ERROR rows. Outcome:
+- 4 new YES (judged correct)
+- 13 new NO (judged wrong but valid)
+- 2 new PARTIAL
+- 3 still ERROR (genuinely undecidable / model returned nothing)
+
+Lifetime aggregate jumped **5/171 = 2.9% → 9/171 = 5.3%**. Per-category
+deltas: Math +1, Bio/Med +1, Humanities/Social Science +2. Aggregator
+now prefers `rejudged.jsonl` over `results.jsonl` when present
+(commit c1981fe).
+
+## Q4 → Q3 rollback (2026-05-14 00:26 UTC)
+
+User decision after the Q4 30-Q math overnight (2/30 = 6.7%, 87%
+stall rate) and the AR-OFF disambiguation: **no measurable Q4
+benefit**, swap back to Q3_K_M. Container now serves
+`/models/gemma-4-26B-A4B-it-UD-Q3_K_M.gguf` via
+`/data3/Models/start_gemma4_llamacpp.sh`. Swap took 18s. Frees ~4 GB
+VRAM (12.1 GB vs Q4's 16.2 GB). The Q3 vs Q4 stall-rate comparison
+will fall out naturally as the hourly babysitter accumulates 30+ Q3
+attempts (~3 cron ticks at 10-Q each).
+
+## Continuous HLE evaluation (2026-05-14)
+
+`scripts/hle_babysitter.sh` (cron line `45 * * * * ...`) keeps a 10-Q
+math HLE batch running every hour. Skips on its own if (a) a prior
+batch is still alive, (b) stress is mid-run, (c) autonomous_review
+is firing, or (d) the balancer at :8001 isn't healthy. Operator
+controls:
+
+- `touch /data3/drydock/.pause_hle_babysitter` — pause future batches
+- `rm /data3/drydock/.pause_hle_babysitter` — resume
+- `kill $(cat /tmp/hle_continuous.pid)` — stop current batch
+- `tail -f /tmp/hle_babysitter.log` — cron-tick history
+
+Each batch lands in `hle_results/run_<ts>/` with results.jsonl +
+summary.json. Multi-batch aggregation is a separate (future) job.
+
 ## Q4 vs AR-OFF disambiguation (2026-05-13)
 
 Two variables shifted simultaneously when the v1 baseline ran (Q3+AR-off

{drydock_cli-2.8.27 → drydock_cli-2.8.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.8.27
+Version: 2.8.28
 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.27 → drydock_cli-2.8.28}/drydock/core/agent_loop.py

@@ -805,8 +805,10 @@ class AgentLoop:
             HARD_STOP_CALLS = int(
                 getattr(self, "_admiral_hard_stop_tool_calls", 100)
             )
-            WRAP_UP_WARN_AT = int(getattr(self, "_admiral_wrap_up_warn_at", 30))
-            STOP_NOW_WARN_AT = int(getattr(self, "_admiral_stop_now_warn_at", 60))
+            WRAP_UP_WARN_AT = int(getattr(self, "_admiral_wrap_up_warn_at",
+                int(os.environ.get("DRYDOCK_WRAP_UP_WARN_AT", 30))))
+            STOP_NOW_WARN_AT = int(getattr(self, "_admiral_stop_now_warn_at",
+                int(os.environ.get("DRYDOCK_STOP_NOW_WARN_AT", 60))))
             _prompt_start = time.perf_counter()
             logger.warning("[TIMING] entering conversation while loop")
             while not should_break_loop:
@@ -852,11 +854,13 @@ class AgentLoop:
                         "summary so the user can review."
                     )
                 elif tool_turns == STOP_NOW_WARN_AT:
+                    _stop_suffix = os.environ.get("DRYDOCK_STOP_NOW_SUFFIX", "")
                     self._inject_system_note(
                         f"You have used {tool_turns} tool calls on this "
                         "single request. STOP NOW. Emit a final text "
                         "response summarizing what you did (or what is "
-                        "blocked) so the user can take the next step."
+                        f"blocked) so the user can take the next step."
+                        + (f" {_stop_suffix}" if _stop_suffix else "")
                     )
                 elif tool_turns >= HARD_STOP_CALLS:
                     # Hard end-of-turn: synthesize a user-facing message
@@ -3350,13 +3354,6 @@ class AgentLoop:
         """
         try:
             from drydock.graphrag import Index
-            db = os.environ.get("DRYDOCK_GRAPHRAG_DB") or str(
-                Path.home() / ".drydock" / "graphrag.sqlite"
-            )
-            if not Path(db).is_file():
-                logger.warning("[AUTO-RETRIEVE] db missing: %s", db)
-                return
-            idx = Index(db)
         except Exception as e:
             logger.warning("[AUTO-RETRIEVE] setup failed: %s", e, exc_info=True)
             return
@@ -3381,19 +3378,62 @@ class AgentLoop:
             return
         logger.warning("[AUTO-RETRIEVE] extracted query: %r", query[:120])
 
-        try:
-            result = idx.retrieve(query, symbol_limit=0, text_limit=4)
-        except Exception as e:
-            logger.warning("[AUTO-RETRIEVE] query failed: %s", e, exc_info=True)
-            return
-
-        text_hits = getattr(result, "text", None) or getattr(result, "text_hits", []) or []
         QUALITY_THRESHOLD = 8.0
-        good_hits = [h for h in text_hits if getattr(h, "score", 0) >= QUALITY_THRESHOLD]
-        logger.warning("[AUTO-RETRIEVE] %d total hits, %d above threshold %.1f",
-                       len(text_hits), len(good_hits), QUALITY_THRESHOLD)
+
+        # DB chain: try the primary index first, then fall back to the
+        # arXiv corpus (if present) on miss. As of 2026-05-14, 77% of
+        # HLE-eval sessions had retrieve return zero above-threshold hits
+        # from the primary corpus — for generic STEM questions the arXiv
+        # corpus at /data3/arxiv_corpus/graphrag.sqlite (1.18M chunks)
+        # has much better recall. The fallback path is operator-tunable
+        # via DRYDOCK_GRAPHRAG_FALLBACK_DB; set to empty to disable.
+        primary_db = os.environ.get("DRYDOCK_GRAPHRAG_DB") or str(
+            Path.home() / ".drydock" / "graphrag.sqlite"
+        )
+        fallback_default = "/data3/arxiv_corpus/graphrag.sqlite"
+        fallback_db_raw = os.environ.get(
+            "DRYDOCK_GRAPHRAG_FALLBACK_DB", fallback_default
+        )
+        fallback_db = fallback_db_raw if fallback_db_raw else None
+        # Don't double-search the same db.
+        db_chain: list[str] = [primary_db]
+        if fallback_db and Path(fallback_db).resolve() != Path(primary_db).resolve():
+            db_chain.append(fallback_db)
+
+        good_hits: list = []
+        text_hits: list = []
+        used_db: str | None = None
+        for db in db_chain:
+            if not Path(db).is_file():
+                logger.warning("[AUTO-RETRIEVE] db missing: %s", db)
+                continue
+            try:
+                idx = Index(db)
+                result = idx.retrieve(query, symbol_limit=0, text_limit=4)
+            except Exception as e:
+                logger.warning(
+                    "[AUTO-RETRIEVE] retrieve failed on %s: %s", db, e
+                )
+                continue
+            hits = getattr(result, "text", None) or getattr(result, "text_hits", []) or []
+            gh = [h for h in hits if getattr(h, "score", 0) >= QUALITY_THRESHOLD]
+            logger.warning(
+                "[AUTO-RETRIEVE] %s: %d total hits, %d above threshold %.1f",
+                db, len(hits), len(gh), QUALITY_THRESHOLD,
+            )
+            if gh:
+                text_hits = hits
+                good_hits = gh
+                used_db = db
+                break
+
         if not good_hits:
             return
+        if used_db != primary_db:
+            logger.warning(
+                "[AUTO-RETRIEVE] primary corpus returned 0 above-threshold "
+                "hits; using fallback %s", used_db,
+            )
 
         # Build the system note. Cap at ~2000 chars total.
         chunks = []
@@ -3426,7 +3466,12 @@ class AgentLoop:
         import uuid
 
         tool_call_id = f"auto-retrieve-{uuid.uuid4().hex[:16]}"
-        tool_args = json.dumps({"query": (user_msg or "")[:200]})
+        # Reflect the CLEANED query (with QUESTION:/FINAL ANSWER: boilerplate
+        # stripped) in the synthesized tool_call arguments — not the raw
+        # user_msg. Operators reading messages.jsonl could otherwise mistake
+        # the noisy full prompt for what BM25 actually scored against, and
+        # the model itself sees the same arguments echoed back in compaction.
+        tool_args = json.dumps({"query": query[:200]})
         synth_assistant = LLMMessage(
             role=Role.assistant,
             content="",

{drydock_cli-2.8.27 → drydock_cli-2.8.28}/drydock/core/classifier/dispatcher.py

@@ -56,17 +56,78 @@ def _queue_path_for(bucket: Bucket, root: Path | None = None) -> Path:
     return (root or _default_queue_root()) / f"{bucket}.jsonl"
 
 
-def make_jsonl_handler(bucket: Bucket, root: Path | None = None) -> DispatchHandler:
+_FINGERPRINT_CAP = 20_000  # keep at most this many fingerprints per bucket
+
+
+def _fingerprint_path(bucket: Bucket, root: Path | None = None) -> Path:
+    return (root or _default_queue_root()) / f".fp_{bucket}"
+
+
+def _signal_fingerprint(signal: FailureSignal) -> str:
+    """Stable hash of (pattern_id, evidence). Used to dedupe a signal
+    that fires repeatedly across cron ticks — without this, a single
+    admiral_history line getting re-classified produces a queue entry
+    per re-classification (observed 2026-05-14: thinking_stall queue
+    had 73.6× amplification, 14213 entries / 193 unique strings)."""
+    import hashlib
+    src = f"{signal.pattern_id}\0{signal.evidence or ''}"
+    return hashlib.sha1(src.encode("utf-8", errors="replace")).hexdigest()
+
+
+def _load_fingerprints(path: Path) -> set[str]:
+    if not path.is_file():
+        return set()
+    try:
+        return set(path.read_text().splitlines())
+    except OSError:
+        return set()
+
+
+def _append_fingerprint(path: Path, fp: str, cap: int = _FINGERPRINT_CAP) -> None:
+    """Append a fingerprint to disk; truncate the file when it exceeds
+    the cap to bound storage."""
+    try:
+        with path.open("a", encoding="utf-8") as f:
+            f.write(fp + "\n")
+    except OSError:
+        return
+    try:
+        if path.stat().st_size > cap * 64:  # rough size guard
+            lines = path.read_text().splitlines()
+            if len(lines) > cap:
+                path.write_text("\n".join(lines[-cap:]) + "\n")
+    except OSError:
+        pass
+
+
+def make_jsonl_handler(
+    bucket: Bucket, root: Path | None = None, *, dedup: bool = True
+) -> DispatchHandler:
     """Build a handler that appends each signal as one JSON line under
     ~/.drydock/dispatch/<bucket>.jsonl (or `root`/<bucket>.jsonl).
 
     Atomicity: each write is one line per signal, with a timestamp.
     The append is open-write-flush-close so concurrent runs don't
-    interleave half-lines."""
+    interleave half-lines.
+
+    Cross-run dedup (`dedup=True`, default): a sidecar file
+    `.fp_<bucket>` holds sha1 fingerprints of `(pattern_id, evidence)`
+    tuples seen in this queue. A signal whose fingerprint is already
+    present is dropped at write time. Bounded to ~20k fingerprints
+    via rolling truncation. The amplification factor observed on
+    2026-05-14 (thinking_stall 73.6×) drops to ~1× with this enabled."""
     path = _queue_path_for(bucket, root)
     path.parent.mkdir(parents=True, exist_ok=True)
+    fp_path = _fingerprint_path(bucket, root)
+    fingerprints: set[str] = _load_fingerprints(fp_path) if dedup else set()
 
     def handler(signal: FailureSignal) -> None:
+        if dedup:
+            fp = _signal_fingerprint(signal)
+            if fp in fingerprints:
+                return
+            fingerprints.add(fp)
+            _append_fingerprint(fp_path, fp)
         record = signal.to_jsonable()
         record["ts"] = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
         with path.open("a", encoding="utf-8") as f:

{drydock_cli-2.8.27 → drydock_cli-2.8.28}/drydock/core/classifier/rules.py

@@ -91,7 +91,25 @@ RULES: tuple[ClassificationRule, ...] = (
     ),
     ClassificationRule(
         pattern_id="harness:tool:hallucinated_name",
-        regex=_r(r"(unknown\s+tool|hallucinated.*tool)"),
+        # Require the line to either name a specific hallucinated tool or
+        # quote the format.py suppression-redirect message. The old regex
+        # `(unknown\s+tool|hallucinated.*tool)` matched any narrative
+        # mention of "hallucinated tools" — autonomous_review.log summary
+        # entries like "addressed thinking_stall, bash loops, hallucinated
+        # tools" fired this 48× during the 2026-05-11→14 window with no
+        # real hallucinated call behind them.
+        regex=_r(
+            # 'unknown tool: <name>' — require colon then an identifier
+            r"(unknown\s+tool:\s*[\w_.-]{3,}"
+            # 'hallucinated tool '<name>'' — require QUOTED name. Excludes
+            # narrative phrases like "hallucinated tool name to ..." that
+            # leaked through the prior regex.
+            r"|hallucinated\s+tool\s+['\"][\w_.-]+['\"]"
+            # format.py redirect-message signature (verbatim) — em-dash + tail
+            r"|'[^']{2,40}'\s+does\s+not\s+exist\s+—\s+do\s+not\s+call"
+            # admiral / detectors narrative phrasing
+            r"|model\s+invented\s+(?:a\s+)?tool\s+['\"][\w_.-]+['\"])"
+        ),
         bucket=Bucket.HARNESS,
         suggested_action="Add the hallucinated tool name to _IGNORE_TOOLS suppression list.",
     ),

{drydock_cli-2.8.27 → drydock_cli-2.8.28}/drydock/core/prompts/gemma4.md

@@ -2,7 +2,7 @@ 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.
+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. Even if you are uncertain, always attempt an answer and write "FINAL ANSWER: <best guess>" — an empty response scores 0 regardless of how good your reasoning was.
 
 Your tools: read_file, write_file, search_replace, grep, glob, bash, task, web_search, web_fetch, retrieve, math, count, memory, verify.
 
@@ -91,6 +91,10 @@ prior alone. The math tool is sandboxed Python (`math.factorial(20)`,
 `math.comb(50,5)`, `Fraction(1,3)+Fraction(1,6)`, `statistics.mean([...])`)
 and returns exact results. Use it. Don't compute in your head.
 
+For "maximize revenue/profit" or "how many X fit in Y" combinatorial problems,
+enumerate ALL feasible combinations with a Python loop in the math tool rather
+than computing by hand — brute-force is exact; manual decomposition is not.
+
 USE THE count TOOL for "how many X" questions over text or files —
 substring, regex, lines, words, chars, bytes. Eyeballing miscounts;
 `count(pattern="def ", path="src/foo.py")` doesn't.

{drydock_cli-2.8.27 → drydock_cli-2.8.28}/drydock/core/tools/builtins/retrieve.py

@@ -199,10 +199,11 @@ class Retrieve(
                 )
                 return
 
+        text_limit = args.text_limit or self.config.default_text_limit
+        symbol_limit = args.symbol_limit or self.config.default_symbol_limit
+
         try:
             idx = Index(db_path)
-            text_limit = args.text_limit or self.config.default_text_limit
-            symbol_limit = args.symbol_limit or self.config.default_symbol_limit
             result = idx.retrieve(
                 args.query,
                 text_limit=text_limit,
@@ -211,7 +212,48 @@ class Retrieve(
         except Exception as e:
             raise ToolError(f"retrieve failed: {e}") from e
 
-        formatted = ingest_note + result.format() if ingest_note else result.format()
+        # Fallback chain — same shape as the auto-prefetch hook in
+        # agent_loop._auto_prefetch_retrieve. When the primary DB returns
+        # nothing useful, fall through to the arXiv corpus (1.18M chunks
+        # of STEM coverage) before giving up. The 2026-05-14 HLE audit
+        # found 77% of sessions hit empty primary — the model-invoked
+        # retrieve path was carrying the same gap.
+        #
+        # Skip fallback when the operator overrode args.db explicitly
+        # (they pointed us at a specific DB on purpose).
+        fallback_note = ""
+        if result.is_empty() and not args.db:
+            fallback_default = "/data3/arxiv_corpus/graphrag.sqlite"
+            fallback_db_raw = os.environ.get(
+                "DRYDOCK_GRAPHRAG_FALLBACK_DB", fallback_default
+            )
+            if fallback_db_raw:
+                fb_path = Path(fallback_db_raw).expanduser()
+                if (fb_path.is_file()
+                        and fb_path.resolve() != db_path.resolve()):
+                    try:
+                        fb_idx = Index(fb_path)
+                        fb_result = fb_idx.retrieve(
+                            args.query,
+                            text_limit=text_limit,
+                            symbol_limit=symbol_limit,
+                        )
+                        if not fb_result.is_empty():
+                            result = fb_result
+                            db_path = fb_path
+                            fallback_note = (
+                                f"[primary index empty; using fallback {fb_path}]\n"
+                            )
+                    except Exception:
+                        # Fallback failure is non-fatal — just emit the
+                        # primary's empty result.
+                        pass
+
+        formatted = (
+            fallback_note + ingest_note + result.format()
+            if (fallback_note or ingest_note)
+            else result.format()
+        )
         yield RetrieveResult(
             found=not result.is_empty(),
             db_path=str(db_path),

{drydock_cli-2.8.27 → drydock_cli-2.8.28}/drydock/curiosity/__main__.py

@@ -146,12 +146,75 @@ def cmd_consume(args: argparse.Namespace) -> int:
     return 0
 
 
-def cmd_reset(_args: argparse.Namespace) -> int:
-    if CONSUMED_STATE.is_file():
-        CONSUMED_STATE.unlink()
-        print(f"Cleared {CONSUMED_STATE}")
-    else:
-        print("No consumed-state file to clear.")
+def cmd_reset(args: argparse.Namespace) -> int:
+    """Two modes:
+      - default: clear the entire consumed-state file (legacy)
+      - --since DATE / --kind NAME / --term-pattern REGEX: bulk-MARK
+        matching items consumed without losing the rest. Useful when
+        a batch of noise (e.g. pre-2026-05-14 FINAL/ANSWER/QUESTION
+        false positives) needs draining without resetting the whole
+        queue.
+    """
+    if not (args.since or args.kind or args.term_pattern):
+        if CONSUMED_STATE.is_file():
+            CONSUMED_STATE.unlink()
+            print(f"Cleared {CONSUMED_STATE}")
+        else:
+            print("No consumed-state file to clear.")
+        return 0
+
+    # Bulk-mark mode.
+    import re
+    from datetime import datetime, timezone
+    cutoff: datetime | None = None
+    if args.since:
+        try:
+            cutoff = datetime.strptime(args.since, "%Y-%m-%d").replace(
+                tzinfo=timezone.utc
+            )
+        except ValueError:
+            print(f"bad --since: {args.since!r} (expect YYYY-MM-DD)")
+            return 2
+    term_re = re.compile(args.term_pattern) if args.term_pattern else None
+
+    consumed = _load_consumed()
+    matched = 0
+    skipped = 0
+    qpath = queue_path()
+    if not qpath.is_file():
+        print(f"No queue at {qpath}")
+        return 0
+    for line in qpath.read_text(errors="replace").splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            item = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        # Date filter
+        if cutoff is not None:
+            ts = item.get("ts") or item.get("created_at") or ""
+            try:
+                ts_dt = datetime.fromisoformat((ts or "").replace("Z", "+00:00"))
+            except (TypeError, ValueError):
+                skipped += 1
+                continue
+            if ts_dt >= cutoff:
+                continue
+        # Kind filter
+        if args.kind and item.get("kind") != args.kind:
+            continue
+        # Term pattern filter
+        if term_re is not None and not term_re.search(item.get("term") or ""):
+            continue
+        iid = item.get("id")
+        if iid and iid not in consumed:
+            consumed.add(iid)
+            matched += 1
+    _save_consumed(consumed)
+    print(f"Marked {matched} items consumed (skipped {skipped} undated).")
+    print(f"Total consumed now: {len(consumed)}")
     return 0
 
 
@@ -172,7 +235,23 @@ def main(argv: list[str] | None = None) -> int:
     ap_consume.add_argument("id")
     ap_consume.set_defaults(func=cmd_consume)
 
-    ap_reset = sub.add_parser("reset", help="clear consumed state")
+    ap_reset = sub.add_parser(
+        "reset",
+        help=("clear consumed state, OR bulk-mark items matching "
+              "--since / --kind / --term-pattern"),
+    )
+    ap_reset.add_argument(
+        "--since", default="",
+        help="YYYY-MM-DD UTC. Marks items older than this consumed.",
+    )
+    ap_reset.add_argument(
+        "--kind", default="",
+        help="Only items with this kind (e.g. unknown_term).",
+    )
+    ap_reset.add_argument(
+        "--term-pattern", default="",
+        help="Regex matched against the term field.",
+    )
     ap_reset.set_defaults(func=cmd_reset)
 
     args = ap.parse_args(argv)