drydock-cli 2.7.36__tar.gz → 2.7.38__tar.gz

drydock_cli-2.7.38/.auto_release.lock

@@ -0,0 +1 @@
+2617636

drydock_cli-2.7.38/.claude/scheduled_tasks.lock

@@ -0,0 +1 @@
+{"sessionId":"31dea7d6-a654-4ba3-b084-169d213e9f36","pid":2530054,"procStart":"433206217","acquiredAt":1777842734259}

{drydock_cli-2.7.36 → drydock_cli-2.7.38}/.gitignore

@@ -209,3 +209,7 @@ test_bank_results/
 research/staged/
 research/traces/
 research/STOP
+
+# HLE eval outputs: per-run TUI logs, session symlinks, and copyrighted
+# HLE dataset content. Never commit.
+hle_results/

drydock_cli-2.7.38/HLE_PRD.md

@@ -0,0 +1,193 @@
+# HLE PRD — drydock + GraphRAG + Deep Noir vs Humanity's Last Exam
+
+**Status as of 2026-05-04 00:40 UTC.** Update on resume.
+
+## Thesis
+
+> drydock + GraphRAG + Deep Noir working together should be able to solve
+> any problem.
+
+HLE is the hardest possible PRD — explicitly designed to defeat frontier
+models. Reaching a defensible local-26B score against it validates that
+the three-leg architecture generalizes. Failures expose which leg is weak.
+
+**Critical rule:** drydock IS the harness. Eval drives questions through
+the real TUI. Never wrap the model directly. Every failure is a drydock-
+or-leg bug to fix, not a harness limitation. See
+`memory/feedback_drydock_is_the_harness.md`.
+
+## The three legs and their current strength
+
+| Leg | What it owns | State | Evidence |
+|-----|--------------|-------|----------|
+| **drydock** | agent loop, tool use, prompts, harness fixes | **strongest** | 70% SWE-bench file match; 49/52 PRD functional tests; 16K+ harness queue actively drained |
+| **GraphRAG** | factual recall over indexed code/text | **medium** | infra works (1842 symbols, 75 chunks); only cwd source ingested; **no general knowledge corpus** |
+| **Deep Noir** | reasoning-mode steering | **weakest** | scaffolding shipped (`drydock/steering/`), `LogitBiasSteeringApplier` wired, hook in agent_loop; **zero vectors trained** — hook is a no-op |
+
+## Phase plan
+
+### Phase 1 — baseline (in flight)
+
+Goal: bare drydock + bare GraphRAG (cwd only) + zero Deep Noir vs HLE.
+This number is the floor.
+
+- ✅ `scripts/hle_eval.py` — single-file orchestrator
+- ✅ `scripts/hle_eval_seed.jsonl` — 7 undergrad questions for pipeline validation
+- ✅ Pipeline validated: 7/7 = 100% on seed (commit 7c3a2d9 + earlier)
+- ✅ HF token landed at `~/.config/drydock/hf_token` (chmod 600)
+- ✅ HLE accessible: 2500 questions total, 2158 text-only, 342 multimodal (skipped)
+- 🟡 **N=200 overnight baseline running** (PID in `/tmp/hle_overnight.pid`,
+      log `/tmp/hle_overnight.log`, results dir under `/data3/drydock/hle_results/`).
+      Started 2026-05-04 00:46 UTC (restarted with Telegram wiring).
+      Expected runtime ~10-16h based on q1's 6 min pace. Each question
+      writes a line to `results.jsonl` incrementally — partial progress
+      is always visible mid-run.
+- 🟡 **Telegram pings configured** (commit ed7f6de, SOTA ref 45.9%):
+  start ping fired; milestone every 50 completions; final + breakdown
+  on completion; crash + resume command on error.
+- ⏳ Phase 1 deliverable: a number — Gemma 4 + bare drydock baseline on HLE
+
+Realistic baseline expectation per pre-run analysis:
+- Bare 26B-A4B without retrieval/steering: ~5–10% on HLE
+- Reaching ~22–25% would be defensible vs ~25–30% frontier scores
+
+### Phase 2 — GraphRAG with knowledge corpus
+
+Goal: ingest enough general knowledge that retrieve answers fact-recall
+questions. Re-run, measure delta.
+
+- ⏳ Identify corpus (Wikipedia subset / arXiv abstracts / textbook chunks)
+- ⏳ Extend `drydock/graphrag/code_indexer.py` ingest path for non-code text
+      (it already supports text via `text_indexer.py`; just needs corpus)
+- ⏳ Bulk ingest into `~/.drydock/graphrag.sqlite`
+- ⏳ Re-run HLE Phase 1 with corpus loaded; measure delta
+- Expected delta: +3 to +7 points if corpus is good, +0 if not
+
+### Phase 3 — Deep Noir reasoning vectors
+
+Goal: train activation-steering vectors on reasoning-failure pairs from
+admiral_history; deposit into `~/.drydock/steering/vectors/`; the
+existing hook applies them. This is the user's research domain.
+
+- ⏳ Extract pairs from admiral_history (model-output / correct-intervention)
+- ⏳ Train vectors per direction: "verify-before-answer", "show-work-explicitly",
+      "consider-units", "minimal-patch"
+- ⏳ Deposit `.npy + .toml` per mode under `~/.drydock/steering/vectors/<mode>/`
+- ⏳ Set `DRYDOCK_STEERING_MODES=<mode1>,<mode2>` env at TUI launch
+- ⏳ Re-run HLE; measure delta vs Phase 2
+- Expected delta: 0 to +3 points; high variance, open research
+
+## Currently running / in flight
+
+| Thing | PID | Log | Notes |
+|-------|-----|-----|-------|
+| stress harness | `/tmp/stress_pid.txt` (was 2219727) | `/tmp/stress_*.log` | 1d 9h+ uptime, ~76% through 1658-prompt suite |
+| llm_balancer | 2462362 (rotates) | `/data3/drydock/logs/balancer.log` | :8001, ~10h uptime |
+| HLE N=200 overnight | `/tmp/hle_overnight.pid` (was 2567027) | `/tmp/hle_overnight.log` | output `/data3/drydock/hle_results/run_*/`; expected 10-16h |
+
+## Resume checklist (if connection dropped)
+
+```bash
+# 1. Where are we?
+date -u
+git -C /data3/drydock log --oneline --since="6 hours ago"
+git -C /data3/drydock describe --tags --abbrev=0     # current PyPI tag
+
+# 2. HLE run status
+ps -p $(cat /tmp/hle_overnight.pid 2>/dev/null) -o pid,etime,comm
+ls /data3/drydock/hle_results/
+tail -50 /tmp/hle_overnight.log
+n_done=$(wc -l < /data3/drydock/hle_results/run_*/results.jsonl 2>/dev/null)
+echo "completed: $n_done / 200"
+
+# 3. If HLE crashed mid-flight, RESUME (skip already-done IDs)
+RUN_DIR=$(ls -td /data3/drydock/hle_results/run_* | head -1)
+nohup /home/bobef/miniconda3/bin/python3 /data3/drydock/scripts/hle_eval.py \
+    --source hle --limit 200 --shuffle --seed 42 --resume "$RUN_DIR" \
+    > /tmp/hle_resume.log 2>&1 &
+
+# 4. If complete, see the score
+cat /data3/drydock/hle_results/run_*/summary.json | python3 -m json.tool
+
+# 5. Infra health
+ps -p 2462362 -o pid,etime
+curl -s --max-time 3 http://localhost:8001/v1/models | head -1
+gh issue list --repo fbobe321/drydock --state open --limit 5
+```
+
+## Known issues + workarounds
+
+1. **`web_search` tool requires permission approval** by default
+   (`ToolPermission.ASK`). In batch eval the harness can't see/respond
+   to the prompt → session stalls. **Workaround:**
+   `--dangerously-skip-permissions` flag passed by `hle_eval.py`.
+   **Real fix:** auto-approve read-only tools when stdin is non-TTY
+   or `DRYDOCK_BATCH_MODE=1`. Memory:
+   `memory/project_hle_phase1_findings.md`.
+
+2. **TUI input handler corrupts rapid char-by-char multi-line pexpect
+   input.** Internal `\n` chars get partially eaten + spurious newlines
+   inserted on long prompts. **Workaround:** single-line prompts in
+   `hle_eval.py`. **Real fix:** debug `drydock/cli/textual_ui/` input
+   buffer.
+
+3. **Auto_release at 06:00/12:00/18:00/00:00 UTC overwrites site-packages.**
+   In-flight HLE runs survive (each new question is a fresh TUI spawn that
+   picks up the new binary), but if you direct-edit site-packages your
+   changes vanish. Always commit to source. Pause via:
+   `touch /data3/drydock/.pause_auto_release`.
+
+4. **PRD contamination: model edits `PRD.md` mid-session.** HLE doesn't
+   touch this — every HLE question gets a fresh empty cwd. Not a concern
+   for HLE; relevant for shakedown PRD runs.
+
+5. **Sessions take real time.** HLE questions involve web_search +
+   multi-step reasoning. Seed q's took 30-60s; HLE q's appear to take
+   5+ min each (q1: 5 min in and still working). Expect N=20 to take
+   1-2 hours, N=100 overnight.
+
+## Sentinels currently set
+
+- `/data3/drydock_test_projects/.pause_watchdog` — watchdog cron paused
+- `/data3/drydock/.pause_auto_release` — NOT set (auto_release is active)
+- `/data3/drydock/research/STOP` — research loop sentinel (per gitignore)
+
+## Tomorrow morning's first action
+
+If overnight run completed:
+1. `cat /data3/drydock/hle_results/run_*/summary.json` for the baseline number
+2. If <10%, the diagnosis is in the per-question `verdict` and `judge_reasoning`
+   fields. Sort by category to see if math/physics/CS dominate the failures.
+3. Commit the results JSON (with HLE content redacted to just IDs+verdicts —
+   never commit the question text per HLE license).
+4. Decide Phase 2 corpus based on category distribution of failures.
+
+If overnight run crashed:
+1. `--resume` flag re-enters where it stopped (skip-by-id from results.jsonl).
+2. Likely failure modes: vLLM OOM on a long-thinking question, balancer
+   crash from a port conflict, drydock TUI hang on a tool error.
+   Investigate via the per-question `tui_logs/<id>.tui.log` files.
+
+## File map
+
+```
+/data3/drydock/
+├── scripts/
+│   ├── hle_eval.py                 # the orchestrator (this PRD's main artifact)
+│   ├── hle_eval_seed.jsonl         # 7 hand-crafted seed questions
+│   └── consume_retrieval_queue.py  # GraphRAG-leg autonomy (28× perf-fixed)
+├── hle_results/                    # gitignored — per-run outputs
+│   └── run_<ts>/
+│       ├── config.json
+│       ├── results.jsonl
+│       ├── summary.json
+│       ├── tui_logs/<id>.tui.log
+│       └── work/<id>/              # per-question fresh cwd
+├── HLE_PRD.md                      # this file
+└── ~/.config/drydock/hf_token      # gated cais/hle access
+```
+
+## What "done" looks like for Phase 1
+
+A number. With distribution. Per-category and overall. Writeup in this
+PRD. Commit the writeup, not the questions. Decide Phase 2 from there.

{drydock_cli-2.7.36 → drydock_cli-2.7.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.7.36
+Version: 2.7.38
 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.7.36 → drydock_cli-2.7.38}/drydock/core/classifier/rules.py

@@ -71,7 +71,7 @@ RULES: tuple[ClassificationRule, ...] = (
     ),
     ClassificationRule(
         pattern_id="harness:tool:hallucinated_name",
-        regex=_r(r"(unknown\s+tool|empty_after_tool[:\s]*\w+|hallucinated.*tool)"),
+        regex=_r(r"(unknown\s+tool|hallucinated.*tool)"),
         bucket=Bucket.HARNESS,
         suggested_action="Add the hallucinated tool name to _IGNORE_TOOLS suppression list.",
     ),
@@ -84,7 +84,7 @@ RULES: tuple[ClassificationRule, ...] = (
     ),
     ClassificationRule(
         pattern_id="harness:thinking_stall",
-        regex=_r(r"(empty[-\s]*response|thinking[-\s]*stall|empty\s+assistant\s+message)"),
+        regex=_r(r"(empty[-\s]*response|thinking[-\s]*stall|empty\s+assistant\s+message|empty_after_tool[:\s]*\w+)"),
         bucket=Bucket.HARNESS,
         suggested_action="Pop empty message and inject 'Continue working' nudge.",
     ),

{drydock_cli-2.7.36 → drydock_cli-2.7.38}/drydock/core/tools/builtins/bash.py

@@ -550,6 +550,31 @@ class Bash(
 
             returncode = proc.returncode or 0
 
+            # Proactive heredoc-write confirmation.  When `cat <<EOF > file`
+            # succeeds silently (empty stdout, rc=0), the model can't tell the
+            # file landed and re-runs the same heredoc.  Check the file on disk
+            # and confirm immediately so the model moves on without a retry.
+            import re as _re_hd
+            import os as _os_hd
+            _hd_match = _re_hd.search(
+                r"cat\s+<<\s*['\"]?[A-Za-z_]*['\"]?\s+>+\s*(\S+)", args.command
+            )
+            if _hd_match and returncode == 0 and not stdout.strip():
+                _hd_path = _hd_match.group(1).strip().rstrip(";")
+                if _os_hd.path.exists(_hd_path):
+                    _hd_size = _os_hd.path.getsize(_hd_path)
+                    _hd_lines = 0
+                    try:
+                        with open(_hd_path, "r", errors="replace") as _hdf:
+                            _hd_lines = sum(1 for _ in _hdf)
+                    except Exception:
+                        pass
+                    stdout = (
+                        f"[File written: {_hd_path} ({_hd_lines} lines, "
+                        f"{_hd_size} bytes). "
+                        f"The file is on disk — do not re-run this command.]"
+                    )
+
             # Mechanical loop-breaker (ADVISORY ONLY — never raise
             # ToolError; see feedback_no_tool_errors_for_loop_detection.md).
             # Two complementary checks:
@@ -561,6 +586,15 @@ class Bash(
             state = self.state.__dict__.setdefault("_bash_history", {})
             # Track total error-exit calls per command (regardless of output).
             err_state = self.state.__dict__.setdefault("_bash_err_count", {})
+            # Track consecutive empty-stdout search commands (any command, not
+            # just identical ones).  The model semantic-loops by trying different
+            # search terms for a non-existent target:
+            #   ls | grep "test_cli" → empty → ls | grep "test_race" → empty → ...
+            # Each command is unique so the identical-hash check never fires.
+            # After 5 consecutive empty searches reset is_search → nudge.
+            _consec_empty_search_state = self.state.__dict__.setdefault(
+                "_consec_empty_searches", {"count": 0}
+            )
             if returncode != 0:
                 err_count = err_state.get(args.command, 0) + 1
                 err_state[args.command] = err_count
@@ -597,6 +631,22 @@ class Bash(
                     _is_heredoc_write = bool(_re.search(
                         r"cat\s+<<\s*['\"]?EOF['\"]?\s+>", args.command
                     ))
+                    # Detect ls/grep/find search that returned empty output.
+                    # The model runs `ls -F | grep "test_cli"` repeatedly when
+                    # the file doesn't exist — each run returns empty stdout.
+                    # Generic "EDIT SOURCE CODE" is confusing; tell it to
+                    # stop searching and create the file instead.
+                    # grep/rg return rc=1 when no matches found; ls returns 0.
+                    # Accept both as "empty search" since the key signal is
+                    # empty stdout on a repeated search command.
+                    _is_empty_search = (
+                        not stdout.strip()
+                        and returncode in (0, 1)
+                        and bool(_re.search(
+                            r'(?:^|\|)\s*(?:ls\b|grep\b|find\b|rg\b)',
+                            args.command,
+                        ))
+                    )
                     # Detect echo -e / printf with \n or \t escape sequences.
                     # These loops when the shell doesn't interpret the escapes
                     # (e.g. dash ignores echo -e; backslash doubling in quoting
@@ -606,7 +656,27 @@ class Bash(
                     _is_echo_escape = bool(_re.search(
                         r'(?:echo\s+.*-[eE]|printf)\b', args.command
                     ) and _re.search(r'\\[nt]', args.command))
-                    if _is_heredoc_write:
+                    # Detect sed -i with \n or \t in substitution patterns.
+                    # GNU sed interprets \n in replacement strings but the shell
+                    # may swallow the backslash before sed sees it (depends on
+                    # quote style). The model loops retrying the same sed
+                    # command when the substitution silently fails.
+                    _is_sed_escape = bool(_re.search(
+                        r"\bsed\b.*-i\b", args.command
+                    ) and _re.search(r"\\[nt\\]", args.command))
+                    if _is_empty_search:
+                        notice = (
+                            f"[NOTICE: this is the #{entry['count']}th identical "
+                            f"run of `{cmd_preview}` — it returned empty output "
+                            f"every time. The file, symbol, or pattern you are "
+                            f"searching for does not exist yet. "
+                            f"STOP searching — you will keep getting empty results. "
+                            f"Either CREATE the missing file/function with "
+                            f"write_file or search_replace, or ask the user what "
+                            f"'{cmd_preview[:40]}' refers to. "
+                            f"Do NOT re-run this search unchanged.]"
+                        )
+                    elif _is_heredoc_write:
                         notice = (
                             f"[NOTICE: this is the #{entry['count']}th identical "
                             f"heredoc write of `{cmd_preview}`. "
@@ -630,6 +700,18 @@ class Bash(
                             f"OR use write_file to create the test file directly. "
                             f"Do NOT re-run this command unchanged.]"
                         )
+                    elif _is_sed_escape:
+                        notice = (
+                            f"[NOTICE: this is the #{entry['count']}th identical "
+                            f"run of `{cmd_preview}` — the sed substitution with "
+                            f"\\n / \\t escape sequences is a no-op. Shell quoting "
+                            f"may have consumed the backslash before sed sees it, "
+                            f"or the search pattern doesn't match any line. "
+                            f"Use search_replace with a proper SEARCH/REPLACE block "
+                            f"to make exact text edits, or use write_file to "
+                            f"rewrite the file with the corrected content. "
+                            f"Do NOT re-run this sed command unchanged.]"
+                        )
                     else:
                         notice = (
                             f"[NOTICE: this is the #{entry['count']} identical "
@@ -649,6 +731,33 @@ class Bash(
             else:
                 state[args.command] = {"hash": out_hash, "count": 1}
 
+            # Consecutive-empty-search cross-command check (C).  Tracks any
+            # ls/grep/find/rg that returned empty stdout, regardless of command
+            # text.  Resets on any search with non-empty output.  After 5
+            # consecutive empty searches, injects a clarification nudge.
+            import re as _re2
+            _is_any_search = bool(_re2.search(
+                r'(?:^|\|)\s*(?:ls\b|grep\b|find\b|rg\b)', args.command
+            ))
+            if _is_any_search:
+                if not stdout.strip() and returncode in (0, 1):
+                    _consec_empty_search_state["count"] += 1
+                else:
+                    _consec_empty_search_state["count"] = 0
+            _consec = _consec_empty_search_state["count"]
+            if _is_any_search and _consec >= 5 and not stdout.strip():
+                cmd_preview2 = args.command[:80]
+                stdout = (
+                    f"[LOOP-BREAKER: {_consec} consecutive search commands have "
+                    f"all returned empty results (most recent: `{cmd_preview2}`). "
+                    f"The thing you are looking for does NOT exist in this project. "
+                    f"STOP searching. Either (a) CREATE the missing file/function "
+                    f"with write_file or search_replace, or (b) ask the user to "
+                    f"clarify what they meant — e.g. 'I don't see any test for "
+                    f"\"bug B\" — can you clarify what component you mean?'. "
+                    f"Do NOT run another search command.]"
+                )
+
             yield self._build_result(
                 command=args.command,
                 stdout=stdout,

{drydock_cli-2.7.36 → drydock_cli-2.7.38}/pyproject.toml

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

{drydock_cli-2.7.36 → drydock_cli-2.7.38}/scripts/autonomous_review_prompt.md

@@ -12,6 +12,10 @@ without them.
    - Group by `pattern_id`, sort by recent `ts`. Pick the most-fired recent pattern that is NOT already addressed by a commit in the last 24h (`git log --since="24 hours ago" --oneline`).
    - The `suggested_action` is your starting hypothesis — verify against current source before implementing.
    - If you fix a queued pattern, mention `addresses pattern <pattern_id>` in the commit message so future ticks can dedup.
+2a. **Drain the RETRIEVAL bucket**: run `/home/bobef/miniconda3/bin/python3 /data3/drydock/scripts/consume_retrieval_queue.py --apply`
+    - This is non-source-fix work: it reads `~/.drydock/dispatch/retrieval.jsonl`, finds the affected project for each entry, and ingests it into GraphRAG so the retrieve tool can answer cross-package symbol queries on the next session.
+    - Idempotent + dedup'd via `~/.drydock/dispatch/.retrieval_consumed.json` (7-day re-ingest window). Cheap, ~20s per project.
+    - If it ingests anything, note it in the trip_log line as `retrieval-drain: N project(s) ingested`.
 3. Run the STATUS COMMANDS block from resume.md to check stress run health.
 4. Scan for new failure patterns NOT in the dispatch queue:
    - Has the stress harness died? (PID in `/tmp/stress_pid.txt`)

drydock_cli-2.7.38/scripts/consume_retrieval_queue.py

@@ -0,0 +1,214 @@
+#!/usr/bin/env python3
+"""Consume the RETRIEVAL bucket from the classifier dispatch queue.
+
+For each fresh entry in ~/.drydock/dispatch/retrieval.jsonl:
+  - parse the evidence-row timestamp
+  - find the session whose start_time is within +/-1h of it
+  - read the session's working_directory
+  - if that project hasn't been ingested into GraphRAG in the last 7 days,
+    run `python -m drydock.graphrag ingest <project>`
+
+State is tracked in ~/.drydock/dispatch/.retrieval_consumed.json so reruns
+are idempotent and cheap.
+
+This is the closing-the-loop step the framework was missing: the classifier
+flagged 12+ retrieval-pattern hits but no consumer was actually ingesting
+the affected projects' source into GraphRAG.
+
+Usage:
+    python3 scripts/consume_retrieval_queue.py            # dry run
+    python3 scripts/consume_retrieval_queue.py --apply    # do the ingest
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+DISPATCH_DIR = Path.home() / ".drydock" / "dispatch"
+QUEUE = DISPATCH_DIR / "retrieval.jsonl"
+STATE = DISPATCH_DIR / ".retrieval_consumed.json"
+SESSION_ROOT = Path.home() / ".vibe" / "logs" / "session"
+
+REINGEST_AFTER_DAYS = 7
+SESSION_MATCH_WINDOW = timedelta(hours=1)
+EVIDENCE_TS = re.compile(r"^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:[+-]\d{2}:\d{2}|Z))")
+
+
+def _parse_iso(s: str) -> datetime | None:
+    try:
+        return datetime.fromisoformat(s.replace("Z", "+00:00"))
+    except Exception:
+        return None
+
+
+def _load_state() -> dict[str, str]:
+    if not STATE.exists():
+        return {}
+    try:
+        return json.loads(STATE.read_text())
+    except Exception:
+        return {}
+
+
+def _save_state(state: dict[str, str]) -> None:
+    STATE.parent.mkdir(parents=True, exist_ok=True)
+    STATE.write_text(json.dumps(state, indent=2, sort_keys=True))
+
+
+def _evidence_timestamp(evidence: str) -> datetime | None:
+    m = EVIDENCE_TS.match(evidence or "")
+    return _parse_iso(m.group(1)) if m else None
+
+
+def _read_queue() -> list[dict]:
+    if not QUEUE.exists():
+        return []
+    out: list[dict] = []
+    for line in QUEUE.read_text().splitlines():
+        if not line.strip():
+            continue
+        try:
+            out.append(json.loads(line))
+        except Exception:
+            continue
+    return out
+
+
+_DIRNAME_TS = re.compile(r"^session_(\d{8})_(\d{6})_")
+
+
+def _dirname_to_dt(name: str) -> datetime | None:
+    """Parse a session directory name into a UTC datetime without reading
+    meta.json. Drydock encodes start time in the dir name as
+    `session_YYYYMMDD_HHMMSS_<id>`."""
+    m = _DIRNAME_TS.match(name)
+    if not m:
+        return None
+    try:
+        return datetime.strptime(m.group(1) + m.group(2),
+                                 "%Y%m%d%H%M%S").replace(tzinfo=timezone.utc)
+    except Exception:
+        return None
+
+
+def _find_session_cwd(target: datetime) -> Path | None:
+    """Find the session whose start_time is closest to `target` and within
+    SESSION_MATCH_WINDOW.
+
+    Two-stage filter: we used to read every meta.json under SESSION_ROOT
+    (10K+ files, ~40s wall) which made autonomous_review's per-bash
+    timeout abandon this consumer every tick. Now we filter on the
+    directory-name timestamp first (zero I/O), then only read meta.json
+    for the handful of candidates within the time window.
+    """
+    if not SESSION_ROOT.exists():
+        return None
+    window_s = SESSION_MATCH_WINDOW.total_seconds()
+    candidates: list[tuple[float, Path]] = []
+    for entry in SESSION_ROOT.iterdir():
+        if not entry.is_dir():
+            continue
+        dt = _dirname_to_dt(entry.name)
+        if dt is None:
+            continue
+        if abs((dt - target).total_seconds()) > window_s:
+            continue
+        meta = entry / "meta.json"
+        try:
+            data = json.loads(meta.read_text())
+        except Exception:
+            continue
+        start = _parse_iso(data.get("start_time", "")) or dt
+        delta = abs((start - target).total_seconds())
+        if delta > window_s:
+            continue
+        cwd = (data.get("environment") or {}).get("working_directory")
+        if cwd:
+            candidates.append((delta, Path(cwd)))
+    if not candidates:
+        return None
+    candidates.sort()
+    return candidates[0][1]
+
+
+def _stale(state: dict[str, str], project: Path) -> bool:
+    last = _parse_iso(state.get(str(project), ""))
+    if last is None:
+        return True
+    return datetime.now(timezone.utc) - last > timedelta(days=REINGEST_AFTER_DAYS)
+
+
+def _ingest(project: Path) -> tuple[int, str]:
+    cmd = [sys.executable, "-m", "drydock.graphrag", "ingest", str(project)]
+    proc = subprocess.run(cmd, capture_output=True, text=True, timeout=180)
+    return proc.returncode, (proc.stdout + proc.stderr).strip()
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--apply", action="store_true",
+                    help="actually run graphrag ingest (default is dry-run)")
+    ap.add_argument("--limit", type=int, default=20,
+                    help="max projects to ingest per run")
+    args = ap.parse_args()
+
+    entries = _read_queue()
+    if not entries:
+        print("[retrieval-consumer] queue empty, nothing to do")
+        return 0
+
+    state = _load_state()
+    targets: dict[str, datetime] = {}
+    skipped_no_session = 0
+    skipped_no_ts = 0
+
+    for e in entries:
+        ts = _evidence_timestamp(e.get("evidence", ""))
+        if ts is None:
+            skipped_no_ts += 1
+            continue
+        cwd = _find_session_cwd(ts)
+        if cwd is None:
+            skipped_no_session += 1
+            continue
+        if not cwd.exists():
+            continue
+        key = str(cwd)
+        if not _stale(state, cwd):
+            continue
+        prior = targets.get(key)
+        if prior is None or ts > prior:
+            targets[key] = ts
+
+    if not targets:
+        print(f"[retrieval-consumer] {len(entries)} queue entries, "
+              f"0 actionable (skipped: no_ts={skipped_no_ts}, "
+              f"no_session={skipped_no_session}, all already ingested recently)")
+        return 0
+
+    items = list(targets.items())[: args.limit]
+    print(f"[retrieval-consumer] {len(entries)} queue entries → "
+          f"{len(items)} project(s) to ingest"
+          f"{' (DRY RUN — pass --apply to execute)' if not args.apply else ''}")
+
+    for project, ts in items:
+        print(f"  {project}  (evidence ts {ts.isoformat()})")
+        if not args.apply:
+            continue
+        rc, out = _ingest(Path(project))
+        snippet = (out[-300:] if out else "").replace("\n", " | ")
+        print(f"    rc={rc} {snippet}")
+        if rc == 0:
+            state[project] = datetime.now(timezone.utc).isoformat()
+            _save_state(state)
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())