drydock-cli 2.7.35__tar.gz → 2.7.37__tar.gz

drydock_cli-2.7.37/.auto_release.lock

@@ -0,0 +1 @@
+2549736

drydock_cli-2.7.37/.claude/scheduled_tasks.lock

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

{drydock_cli-2.7.35 → drydock_cli-2.7.37}/.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.35 → drydock_cli-2.7.37}/CLAUDE.md

@@ -200,6 +200,57 @@ v3 is a from-scratch rewrite using nano-claude-code as foundation. 4 core files,
 └── start_gemma4.sh                ← Docker startup (vLLM + Gemma 4)
 ```
 
+## Sovereign v2 framework (active as of v2.7.36)
+
+The Sovereign Stack v2 deliverables (per `SOVEREIGN_PRD.md` and
+`TRIAGE_v1.md`) are now shipping. The framework is a **living loop**:
+
+```
+observation (logs)
+   → drydock.core.classifier  (rule-based, 5 buckets)
+   → drydock.core.classifier.dispatcher  (~/.drydock/dispatch/<bucket>.jsonl)
+   → autonomous_review.sh  (consumes harness.jsonl as primary signal)
+   → harness fix shipped via auto_release
+```
+
+Cron wiring:
+
+| Cron | Cadence | Purpose |
+| ---- | ------- | ------- |
+| `scripts/classify_pulse.sh` | `*/10` | Classifies recent log activity, fills queues |
+| `scripts/autonomous_review.sh` | `*/30` | Reads queue, picks highest-priority unhandled, fixes |
+| `scripts/auto_release.sh` | `0 0,6,12,18 * * *` (CDT) | Tags + publishes to PyPI |
+| `scripts/stress_babysitter.sh` | `0 * * * *` | Restarts stress run if dead |
+| `scripts/llm_balancer.py` keepalive | `*/5` | Resurrects balancer if killed |
+| `scripts/telegram_bot.py --daemon` | `*/2` | Resurrects telegram daemon |
+
+Per-fix convention: when an autonomous fix addresses a queued classifier
+pattern, the commit subject prefixes `addresses pattern <pattern_id>:`
+so subsequent ticks dedup naturally via 24h git log.
+
+### Modules added in v2.7.34–v2.7.36
+
+| Path | Purpose |
+| ---- | ------- |
+| `drydock/graphrag/` | GraphRAG: AST symbol indexer + cross-package alias resolution + TF-IDF text retriever + SQLite storage. CLI: `python -m drydock.graphrag {ingest,query,symbol,chain,stats}` |
+| `drydock/steering/` | Deep Noir scaffolding: vector format (.npy + .toml manifest with sha256), registry, SteeringConfig, applier protocol. CLI: `python -m drydock.steering {list,inspect,sha256,eval}` |
+| `drydock/core/classifier/` | Rule-based failure classifier + Dispatcher. CLI: `python -m drydock.core.classifier <log> [--dispatch]` |
+| `drydock/core/tools/builtins/retrieve.py` | Agent-facing `retrieve` tool. Auto-discovered. Auto-ingests cwd on first call when project markers are present. |
+| `drydock/core/steering_hook.py` | Pre-`backend.complete()` hook in agent_loop. Env-gated (`DRYDOCK_STEERING_MODES=...`), log-only by default. |
+| `drydock/core/config/local_detect.py` | First-launch local-LLM autodetection (vLLM/Ollama/llama.cpp/LM Studio). Skips Mistral API-key prompt. |
+
+### Slash commands (live operator control)
+
+- `/graphrag stats|ingest <path>|query <text>` — index control + ad-hoc retrieval
+- `/steering status|on <mode>|off|list` — Deep Noir mode toggle (no-op until vectors land)
+
+### Where signal lives
+
+- Classifier rules: `drydock/core/classifier/rules.py`
+- Bucket taxonomy validated against MODEL_SHORTCOMINGS.md + TRIAGE_v1.md (5 buckets, no `OTHER` matches in v0)
+- Dispatcher queues: `~/.drydock/dispatch/<bucket>.jsonl` — append-only, dedup-aware, structured records
+- Live first pulse produced 211 signals (210 harness, 1 retrieval) — distribution matches the framework's prediction
+
 ## Configuration Management
 
 **All scripts use explicit Python path:** `/home/bobef/miniconda3/bin/python3`

drydock_cli-2.7.37/JETSON_BENCH.md

@@ -0,0 +1,99 @@
+# Jetson AGX Orin vs Local vLLM — gemma-4-26b Benchmark
+
+**Date:** 2026-05-03 12:30 UTC
+**Jetson endpoint:** `http://192.168.50.19:8080` (llama.cpp / llama-server, GGUF)
+**Local vLLM:** `http://localhost:8001` (vLLM Docker, AWQ-4bit, 2× RTX 4060 Ti)
+**Model:** Both serve `gemma-4-26b` (26B MoE, ~4B active params)
+
+---
+
+## Headline numbers
+
+| Workload | Jetson e2e | vLLM e2e | Speedup | Jetson TTFT | vLLM TTFT |
+|----------|------------|----------|---------|-------------|-----------|
+| short  (~50 in, 64 out)   | **14.5 tok/s** | 61.5 tok/s | vLLM 4.2× | 0.72 s | 0.53 s |
+| medium (~2 K in, 256 out) | **15.1 tok/s** | 46.6 tok/s | vLLM 3.1× | **0.30 s** | 1.47 s |
+
+Jetson decode-only rate (measurable because llama.cpp actually streams):
+**15–17 tok/s** sustained.
+
+---
+
+## What's surprising
+
+1. **Jetson wins TTFT on the medium workload** (0.30 s vs 1.47 s). Two
+   plausible reasons:
+   - The local-vLLM medium TTFT was captured during the active stress
+     run (queue contention). The "uncontested" baseline run earlier
+     showed similar 1.47 s — but that was also during the stress
+     wind-down. Worth re-measuring vLLM TTFT on a fully idle box.
+   - llama.cpp's GGUF prefill on the Jetson AGX Orin's tensor cores
+     may be more efficient than vLLM's AWQ-4bit dequantize-then-prefill
+     pass on Ada-Lovelace cards for moderate prompt sizes.
+2. **Decode rate is where vLLM crushes Jetson** — 3–4× faster sustained
+   token generation. The 4060 Ti's higher memory bandwidth (288 GB/s × 2)
+   beats the AGX Orin's unified 204 GB/s for transformer decode.
+3. **Jetson llama-server returns `reasoning_content` by default** — the
+   model is in thinking mode out of the box. Affects how the harness
+   counts content chunks; `perf_sweep.py` was patched to track both
+   `delta.content` and `delta.reasoning_content` (see
+   commit accompanying this doc).
+
+---
+
+## Practical implications for "Jetson testing for a label"
+
+- **Single-user inference, short responses (≤256 tokens):** Jetson is
+  fine. ~17 s for a 256-token response is acceptable for a real-time
+  coding-assistant turn that includes some thinking.
+- **Long-context analysis (10K+ input):** Jetson degrades. Was queue-
+  blocked for 7+ minutes on a 64K xlong workload during the initial run
+  — had to abort. vLLM handles the same in seconds.
+- **Stress harness / batch evaluation:** Use vLLM. Jetson would take
+  ~5× the wall-clock time for the 1658-prompt PRD suite.
+- **Air-gapped / edge deployments where Jetson is the *only* option:**
+  Defensible. ~15 tok/s is bearable; just budget 10–60 s response times
+  in the UX.
+
+---
+
+## How to reproduce
+
+```bash
+# Foreground, both workloads, fixed harness
+PYTHONUNBUFFERED=1 /home/bobef/miniconda3/bin/python3 -u \
+    /data3/drydock/scripts/perf_sweep.py baseline \
+    --base-url http://192.168.50.19:8080/v1 \
+    --model gemma-4-26b \
+    --workloads short,medium \
+    --iters 5
+```
+
+DO NOT run `--workloads short,medium,long,xlong` against the Jetson
+without watching the wall clock — xlong (64 K input tokens) appears to
+queue-block llama-server for several minutes on this hardware.
+
+---
+
+## What changed in `perf_sweep.py`
+
+- `delta.reasoning_content` is now treated as content for TTFT and
+  chunk-counting. Without this, the Jetson's thinking-mode output
+  registered as 0 chunks → harness reported "all errored" even on
+  successful runs. Fix is forward-compatible with vLLM (which emits
+  `delta.content` exclusively).
+
+---
+
+## Operator notes
+
+- **Jetson endpoint is read-only from drydock's perspective.** Per the
+  long-standing rule (see project memory), drydock does not admin the
+  Jetson. The benchmark only hits the OpenAI-compatible API.
+- **`stream=true` is the default on llama-server.** Streaming worked
+  cleanly through the openai client.
+- **Reasoning mode:** on this Jetson build (`b1-e5f070a`), the default
+  chat format is "Content-only" but the model still emits reasoning. To
+  disable thinking-mode emission, the operator would set
+  `reasoning_format: "none"` and `reasoning_in_content: true` per
+  request. Not done in this benchmark — measured the as-shipped behavior.

{drydock_cli-2.7.35 → drydock_cli-2.7.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.7.35
+Version: 2.7.37
 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.35 → drydock_cli-2.7.37}/SOVEREIGN_PRD.md

@@ -480,34 +480,52 @@ mitigates several of the failure classes already in `MODEL_SHORTCOMINGS.md`.
 - ✅ Drydock harness (v2 TUI + v3 rewrite)
 - ✅ Coding workflows + 370-PRD benchmark
 - ✅ Admiral, stress harness, autonomous review
-- ▢ **Hosting performance sweep** — lock the inference floor (`PERF_SWEEP_PLAN.md`)
-- ▢ **Manual failure triage** — seed the classifier taxonomy from existing
-  diagnostic data (`MODEL_SHORTCOMINGS.md`, `BASELINE_412.md`, Admiral logs)
-- ▢ **Read-before-write enforcement** in the harness
-- ▢ Customer-hardware portability bring-up (llama.cpp + Ollama backends)
-
-### Phase 2 — 60 days (Classifier + GraphRAG first cut)
-
-- ▢ **Failure classifier** — extends Admiral / runs as a sibling; emits
-  structured signals tagged harness-class / retrieval-class / steering-class /
-  model-prior / ambiguous-input
-- ▢ **GraphRAG ingestion pipeline** (PDFs, code, markdown) — first cut, ships
-  as a deployable module
-- ▢ **Pluggable retriever interface** in Drydock (vector + graph backends)
-- ▢ Memory routing (when to retrieve, when not to)
+- ✅ **Hosting performance sweep** — clean baseline captured 2026-05-02
+  (44–62 tok/s e2e, `perf_results/baseline_1777732278.json`)
+- ✅ **Manual failure triage** — `TRIAGE_v1.md`, 11 patterns mapped,
+  GraphRAG + Deep Noir justified by data
+- ✅ **Read-before-write enforcement** — shipped in `write_file.py` +
+  `search_replace.py` advisory paths (already in v2.7.30+)
+- ✅ **Install auto-detect** — fresh installs detect local vLLM/Ollama/
+  llama.cpp/LM Studio and skip the Mistral API-key prompt (v2.7.34)
+- ▢ Customer-hardware portability bring-up (llama.cpp + Ollama backends
+  beyond detection — full provider configs)
+
+### Phase 2 — 60 days (Classifier + GraphRAG)  *— shipping live as of v2.7.36*
+
+- ✅ **Failure classifier** — `drydock.core.classifier`, rule-based v0
+  (LLM swap-in is v1). 5-bucket taxonomy: harness / retrieval / steering /
+  model_prior / ambiguous_input. CLI + `--dispatch` flag.
+- ✅ **Per-bucket Dispatcher** — routes signals to
+  `~/.drydock/dispatch/<bucket>.jsonl` queues, dedup, error isolation,
+  pluggable handlers
+- ✅ **Periodic pulse** — `*/10` cron classifies + dispatches recent log
+  activity; live pulse produced 211 signals (210 harness, 1 retrieval —
+  matches predicted distribution exactly)
+- ✅ **GraphRAG first cut** — `drydock.graphrag`, AST symbol indexer
+  with cross-package alias resolution + TF-IDF text retriever + SQLite
+  storage + CLI (v2.7.34)
+- ✅ **Retriever interface in Drydock** — `retrieve` builtin tool,
+  auto-discovered, auto-ingest on first call when cwd looks like a project
+- ✅ `/graphrag` slash command (stats / ingest / query)
+- ✅ autonomous_review consumes dispatch queue as primary signal
+- ▢ Embeddings backend (sentence-transformers) behind same Retriever protocol
 - ▢ Citation-mode prompt templates + grounding eval
-- ▢ Operator dashboards (per-class failure rates over time)
 
-### Phase 3 — 90 days (Deep Noir first cut + self-improvement)
-
-- ▢ **Deep Noir steering** — first cut, ships as a deployable module;
-  initial vectors for reduced-hallucination, secure-coding, citation modes
-- ▢ Steering hook in the harness; sandbox eval per new vector
-- ▢ Classifier-driven dispatch: harness-class signals open auto-PRs to
-  drydock; retrieval-class signals queue corpus gaps; steering-class signals
-  queue vector candidates
+### Phase 3 — 90 days (Deep Noir + self-improvement)  *— scaffolding shipping as of v2.7.36*
+
+- ✅ **Deep Noir scaffolding** — `drydock.steering`, vector format
+  (.npy + .toml manifest with sha256), registry, SteeringConfig, three
+  applier implementations (Null/LogOnly/sidecar-stub), sandbox eval
+- ✅ **Steering hook in agent_loop** — env-gated, log-only by default,
+  zero behavior change until DRYDOCK_STEERING_MODES is set
+- ✅ `/steering` slash command (status / on / off / list)
+- ▢ Real vLLM sidecar applier — drops in as a single class behind the
+  existing SteeringApplier protocol when vectors arrive
+- ▢ Initial vectors (operator's Deep Noir research output)
+- ▢ Per-vector sandbox eval gating — auto-promote if zero regressions on
+  the regression suite
 - ▢ Execution trace logging (full prompts + tool calls per task)
-- ▢ Autonomous upgrade loop (**local-only** proposer)
 - ▢ First paid pilot ($5–25K, defense-adjacent)
 
 ### Phase 4 — 120 days (Hardening + verticals)

{drydock_cli-2.7.35 → drydock_cli-2.7.37}/drydock/cli/commands.py

@@ -111,6 +111,20 @@ class CommandRegistry:
                             "proposals.",
                 handler="_admiral_status_command",
             ),
+            "graphrag": Command(
+                aliases=frozenset(["/graphrag", "/rag"]),
+                description="GraphRAG index control "
+                            "(usage: /graphrag stats | ingest <path> | "
+                            "query <text>). No arg shows stats + path.",
+                handler="_graphrag_command",
+            ),
+            "steering": Command(
+                aliases=frozenset(["/steering", "/noir"]),
+                description="Deep Noir steering control "
+                            "(usage: /steering | /steering on <mode> | "
+                            "/steering off | /steering list).",
+                handler="_steering_command",
+            ),
         }
 
         for command in excluded_commands:

{drydock_cli-2.7.35 → drydock_cli-2.7.37}/drydock/cli/textual_ui/app.py

@@ -1573,6 +1573,187 @@ class DrydockApp(App):  # noqa: PLR0904
         except Exception as e:
             await self._mount_and_scroll(UserCommandMessage(f"Error: {e}"))
 
+    async def _graphrag_command(self, args: str = "") -> None:
+        """GraphRAG index control: stats / ingest <path> / query <text>."""
+        from pathlib import Path
+        try:
+            from drydock.graphrag import Index
+            from drydock.core.tools.builtins.retrieve import _resolve_db_path
+        except Exception as e:
+            await self._mount_and_scroll(
+                UserCommandMessage(f"GraphRAG module unavailable: {e}")
+            )
+            return
+
+        parts = args.strip().split(None, 1)
+        sub = parts[0].lower() if parts else "stats"
+        rest = parts[1] if len(parts) > 1 else ""
+        db_path = _resolve_db_path("")
+
+        if sub in ("stats", ""):
+            if not db_path.is_file():
+                msg = (
+                    f"### GraphRAG\n\n"
+                    f"No index at `{db_path}`.\n\n"
+                    f"Create one: `/graphrag ingest .` or "
+                    f"`python -m drydock.graphrag ingest .`"
+                )
+            else:
+                idx = Index(db_path)
+                s = idx.stats()
+                msg = (
+                    f"### GraphRAG\n\n"
+                    f"- DB: `{db_path}`\n"
+                    f"- Symbols: **{s['symbols']}**\n"
+                    f"- Text chunks: **{s['chunks']}**\n"
+                    f"- Unique terms: **{s['unique_terms']}**\n\n"
+                    f"`/graphrag query <text>` to search · "
+                    f"`/graphrag ingest <path>` to refresh."
+                )
+            await self._mount_and_scroll(UserCommandMessage(msg))
+            return
+
+        if sub == "ingest":
+            target = Path(rest or ".").expanduser().resolve()
+            if not target.exists():
+                await self._mount_and_scroll(UserCommandMessage(
+                    f"Path not found: `{target}`"
+                ))
+                return
+            await self._mount_and_scroll(UserCommandMessage(
+                f"Ingesting `{target}` into `{db_path}`..."
+            ))
+            try:
+                idx = Index(db_path)
+                counts = idx.ingest_path(target)
+            except Exception as e:
+                await self._mount_and_scroll(
+                    UserCommandMessage(f"Ingest failed: {e}")
+                )
+                return
+            await self._mount_and_scroll(UserCommandMessage(
+                f"### GraphRAG ingest complete\n\n"
+                f"- Files: **{counts['files']}**\n"
+                f"- Symbols: **{counts['symbols']}**\n"
+                f"- Text chunks: **{counts['chunks']}**\n"
+                f"- DB: `{db_path}`"
+            ))
+            return
+
+        if sub == "query":
+            if not rest:
+                await self._mount_and_scroll(UserCommandMessage(
+                    "Usage: `/graphrag query <text>`"
+                ))
+                return
+            if not db_path.is_file():
+                await self._mount_and_scroll(UserCommandMessage(
+                    f"No index at `{db_path}`. Run `/graphrag ingest .` first."
+                ))
+                return
+            try:
+                idx = Index(db_path)
+                result = idx.retrieve(rest, symbol_limit=5, text_limit=3)
+            except Exception as e:
+                await self._mount_and_scroll(
+                    UserCommandMessage(f"Query failed: {e}")
+                )
+                return
+            formatted = result.format()
+            if len(formatted) > 4000:
+                formatted = formatted[:4000] + "\n... (truncated)"
+            await self._mount_and_scroll(UserCommandMessage(
+                f"### GraphRAG: `{rest}`\n\n```\n{formatted}\n```"
+            ))
+            return
+
+        await self._mount_and_scroll(UserCommandMessage(
+            "Usage: `/graphrag {stats | ingest <path> | query <text>}`"
+        ))
+
+    async def _steering_command(self, args: str = "") -> None:
+        """Deep Noir steering control: status / on <mode> / off / list."""
+        import os
+        try:
+            from drydock.steering import load_registry
+            from drydock.core import steering_hook
+        except Exception as e:
+            await self._mount_and_scroll(
+                UserCommandMessage(f"Steering module unavailable: {e}")
+            )
+            return
+
+        parts = args.strip().split(None, 1)
+        sub = parts[0].lower() if parts else "status"
+        rest = parts[1].strip() if len(parts) > 1 else ""
+
+        registry = load_registry(os.environ.get("DRYDOCK_STEERING_ROOT"))
+        active_modes = os.environ.get("DRYDOCK_STEERING_MODES", "").strip()
+
+        if sub in ("status", ""):
+            modes_list = registry.list_modes()
+            lines = [
+                "### Deep Noir steering",
+                "",
+                f"- Active modes: **{active_modes or '(none)'}**",
+                f"- Registry root: `{registry.root}`",
+                f"- Discovered modes: **{len(modes_list)}**",
+            ]
+            for mode in modes_list:
+                vectors = registry.vectors_for_mode(mode)
+                lines.append(f"  - `{mode}` ({len(vectors)} vector(s))")
+            lines += [
+                "",
+                "`/steering on <mode>` to enable · `/steering off` to disable · "
+                "`/steering list` for full vector inspection.",
+            ]
+            await self._mount_and_scroll(UserCommandMessage("\n".join(lines)))
+            return
+
+        if sub == "on":
+            if not rest:
+                await self._mount_and_scroll(UserCommandMessage(
+                    "Usage: `/steering on <mode>` (or comma list)"
+                ))
+                return
+            os.environ["DRYDOCK_STEERING_MODES"] = rest
+            steering_hook.reset_cache_for_tests()
+            await self._mount_and_scroll(UserCommandMessage(
+                f"Steering enabled: **{rest}** (active for this session). "
+                f"Applier is log-only until real Deep Noir vectors land."
+            ))
+            return
+
+        if sub == "off":
+            os.environ.pop("DRYDOCK_STEERING_MODES", None)
+            steering_hook.reset_cache_for_tests()
+            await self._mount_and_scroll(UserCommandMessage(
+                "Steering disabled."
+            ))
+            return
+
+        if sub == "list":
+            modes_list = registry.list_modes()
+            if not modes_list:
+                await self._mount_and_scroll(UserCommandMessage(
+                    f"No vectors discovered under `{registry.root}`."
+                ))
+                return
+            lines = ["### Discovered steering vectors", ""]
+            for mode in modes_list:
+                lines.append(f"#### `{mode}`")
+                for v in registry.vectors_for_mode(mode):
+                    lines.append(
+                        f"- `{v.name}` — layer {v.layer}, scale {v.scale}, "
+                        f"target `{v.target_model}`"
+                    )
+            await self._mount_and_scroll(UserCommandMessage("\n".join(lines)))
+            return
+
+        await self._mount_and_scroll(UserCommandMessage(
+            "Usage: `/steering {status | on <mode> | off | list}`"
+        ))
+
     async def _show_config(self) -> None:
         """Switch to the configuration app in the bottom panel."""
         if self._current_bottom_app == BottomApp.Config:

{drydock_cli-2.7.35 → drydock_cli-2.7.37}/drydock/core/agent_loop.py

@@ -1547,13 +1547,21 @@ class AgentLoop:
                 self.format_handler.create_failed_tool_response_message(failed, error_msg)
             )
             self.stats.tool_calls_failed += 1
-            # Inject a [SYSTEM: ...] note (the format admiral uses) so the model
-            # is more likely to break out of the empty-response loop that often
-            # follows a suppressed hallucinated-tool call.
-            self._inject_system_note(
-                f"'{failed.tool_name}' does not exist — do NOT call it again. "
-                "Call glob, grep, or read_file NOW to make progress."
-            )
+            # Inject a [SYSTEM: ...] note so the model is more likely to break
+            # out of the empty-response loop that often follows a suppressed
+            # hallucinated-tool call.
+            if "retrieve" in {t for t in self.tool_manager.available_tools}:
+                note = (
+                    f"'{failed.tool_name}' does not exist — do NOT call it again. "
+                    "Call `retrieve(query='<terms>')` to search the project index, "
+                    "or glob/grep/read_file for direct file access. Act NOW."
+                )
+            else:
+                note = (
+                    f"'{failed.tool_name}' does not exist — do NOT call it again. "
+                    "Call glob, grep, or read_file NOW to make progress."
+                )
+            self._inject_system_note(note)
 
     async def _handle_tool_calls(
         self, resolved: ResolvedMessage
@@ -2056,6 +2064,28 @@ class AgentLoop:
                 self._loop_detected = False
                 self._loop_signal = None
 
+            # Deep Noir steering hook — env-gated, log-only by default.
+            # No-op unless DRYDOCK_STEERING_MODES is set; never raises.
+            steering_logit_bias: dict[int, float] | None = None
+            try:
+                from drydock.core.steering_hook import (
+                    decide_for_request,
+                    logit_bias_for_request,
+                )
+                steering_decision = decide_for_request(active_model.name)
+                if steering_decision is not None:
+                    logger.info("[STEERING] %s", steering_decision.summary())
+                    if steering_decision.applier_kind == "logit_bias":
+                        bias = logit_bias_for_request(active_model.name)
+                        if bias:
+                            steering_logit_bias = bias
+                            logger.info(
+                                "[STEERING] logit_bias entries: %d",
+                                len(bias),
+                            )
+            except Exception as _e:  # defense in depth
+                logger.debug("steering hook bypassed: %s", _e)
+
             complete_kwargs = dict(
                 model=active_model,
                 messages=self.messages,
@@ -2070,6 +2100,14 @@ class AgentLoop:
             )
             if extra_sampling:
                 complete_kwargs["extra_sampling"] = extra_sampling
+            if steering_logit_bias:
+                # Merge into extra_sampling so vLLM/Mistral backends pick it up
+                # via SamplingParams. Backends that don't understand logit_bias
+                # will TypeError below and we'll retry without extra_sampling
+                # (keeping inference behavior intact).
+                merged = dict(extra_sampling) if extra_sampling else {}
+                merged["logit_bias"] = steering_logit_bias
+                complete_kwargs["extra_sampling"] = merged
             try:
                 result = await self.backend.complete(**complete_kwargs)
             except TypeError:

drydock_cli-2.7.37/drydock/core/classifier/__init__.py

@@ -0,0 +1,50 @@
+"""Failure classifier — Phase 2 keystone of the Sovereign v2 framework.
+
+The classifier is the bridge between **observation** (admiral fires,
+tool errors, loop-detection signals, session log patterns) and
+**action** (harness PR, GraphRAG corpus tweak, Deep Noir vector
+candidate, LoRA training data).
+
+Without this layer the v2 modules (harness / GraphRAG / Deep Noir) are
+isolated levers a human pulls. With it, every failure produces a
+structured signal — `{bucket, evidence, suggested_action}` — that the
+dispatchers can route to the right module automatically.
+
+For v0 the classifier is rule-based: a registry of regex patterns,
+each tagged with a bucket and an evidence-extraction template. v1+ can
+swap to an LLM classifier behind the same `Classifier` interface; the
+rest of the system never knows the difference.
+
+Public surface:
+    from drydock.core.classifier import (
+        Bucket, FailureSignal, Classifier, classify_text, classify_lines,
+    )
+"""
+from __future__ import annotations
+
+from drydock.core.classifier.classifier import (
+    Classifier,
+    classify_lines,
+    classify_text,
+)
+from drydock.core.classifier.dispatcher import (
+    Dispatcher,
+    DispatchResult,
+    DispatchHandler,
+    default_handler_for,
+    make_jsonl_handler,
+)
+from drydock.core.classifier.signal import Bucket, FailureSignal
+
+__all__ = [
+    "Bucket",
+    "Classifier",
+    "DispatchHandler",
+    "DispatchResult",
+    "Dispatcher",
+    "FailureSignal",
+    "classify_lines",
+    "classify_text",
+    "default_handler_for",
+    "make_jsonl_handler",
+]