drydock-cli 2.7.29__tar.gz → 2.7.30__tar.gz

drydock_cli-2.7.30/.auto_release.lock

@@ -0,0 +1 @@
+2123904

drydock_cli-2.7.30/.claude/scheduled_tasks.lock

@@ -0,0 +1 @@
+{"sessionId":"71137671-5857-422e-ac69-082962e223e2","pid":2049518,"procStart":"416025348","acquiredAt":1777694583206}

{drydock_cli-2.7.29 → drydock_cli-2.7.30}/PKG-INFO

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

@@ -2,7 +2,7 @@
 
 # Project Name: **Drydock Sovereign AI Stack v2**
 
-### Local Adaptive AI System — Gemma 4 26B + Drydock + GraphRAG (roadmap) + Deep Noir (roadmap)
+### Local Adaptive AI System — Gemma 4 26B + Drydock + GraphRAG + Deep Noir (parallel v2 modules)
 
 ---
 
@@ -19,7 +19,7 @@ Drydock has already committed to or measured, the draft loses. Specifically:
 |                                              |                                                    | escalate temp to ~1.0 deliberately as a loop-break lever (`agent_loop.py:2032`).                             |
 | KV cache `q8_0`                              | `--kv-cache-dtype fp8`                             | vLLM-native equivalent. Different ecosystem (vLLM vs. llama.cpp).                                            |
 | Tier 3: Jetson AGX Orin as supported         | **Explicitly out of scope for v2**                 | Per operator rule — Jetson is not to be modified or treated as a deployment target this cycle.               |
-| GraphRAG / Deep Noir / full Evaluator        | **Roadmap**, not "current components"              | We have Admiral, stress harness, MetaHarness, autonomous\_review. GraphRAG and Deep Noir are real future work. |
+| GraphRAG / Deep Noir as faith-based "current" | **First-class roadmap modules**, both ship          | They are deployable v2 capabilities, not contingent on classifier verdict. Classifier sequences engineering attention; it doesn't gate module existence. |
 | Cloud-assisted proposer (anywhere)           | **Local-only proposer**                            | Air-gap is the product pitch; cloud proposer contradicts the brand.                                          |
 
 ---
@@ -38,14 +38,36 @@ The system pairs:
 - **vLLM** — production-grade inference server (Docker, tensor-parallel)
 - **Drydock harness** — orchestration, tool use, loop detection, Admiral
   observer, MetaHarness self-improvement
-- **GraphRAG memory** — *roadmap, Phase 2*
-- **Deep Noir activation steering** — *roadmap, Phase 4 — leverages the
-  operator's own research*
-- **Evaluator loop** — already partially shipped (Admiral + stress + autonomous
-  review); deepens in Phase 3
+- **GraphRAG memory** — first-class deployable module; persistent context for
+  customer corpora (PDFs, code, manuals, tickets). Roadmap: Phase 2 first cut,
+  hardened in Phase 3.
+- **Deep Noir activation steering** — first-class deployable module; behavior
+  shaping via activation vectors derived from the operator's own research.
+  Roadmap: Phase 3 first cut, deepened in Phase 4.
+- **Evaluator + classifier loop** — already partially shipped (Admiral + stress
+  + autonomous review). The classifier (added in Phase 2) sequences which
+  module gets engineering attention next; it does **not** gate whether a module
+  ships.
 
 Category claim: **AI that improves after installation.**
 
+### Module posture (read this before reading the rest)
+
+Two questions are kept separate throughout this PRD:
+
+1. **What ships as a deployable customer module?**
+   *All three:* harness, GraphRAG, Deep Noir. Defense-adjacent and regulated
+   customers ask for these by name; the answer is "yes, here's the module."
+2. **Where does engineering attention go next?**
+   *Classifier-driven.* The Phase 2 classifier tags each failure as
+   harness-class / steering-class / retrieval-class / model-prior /
+   ambiguous-input and feeds a prioritized backlog. The classifier sequences
+   our work; it does **not** decide whether a module exists.
+
+The product is the **living loop** that ties these together: failures get
+classified, the right module gets the fix, the customer's deployment quietly
+improves over time.
+
 ---
 
 # 2. Product Vision
@@ -122,11 +144,11 @@ Drydock Sovereign solves both.
    └──────────────────┘  └─────────────────┘    └──────────────────────┘
                                   │
                          ┌────────▼───────────┐
-                         │  GraphRAG (Phase 2)│  ← persistent memory
+                         │  GraphRAG (Phase 2)│  ← persistent memory module
                          └────────┬───────────┘
                                   │
                          ┌────────▼───────────┐
-                         │ Deep Noir (Phase 4)│  ← activation steering
+                         │ Deep Noir (Phase 3)│  ← activation steering module
                          └────────────────────┘
 ```
 
@@ -237,12 +259,18 @@ The control plane. Already shipped (v2 TUI + v3 clean rewrite).
 - **Read-before-write enforcement** — block / warn when a tool call would
   modify a file the agent never read in this session. Directly addresses the
   "model leans on internal priors instead of retrieval" failure mode (see §10).
-- Pluggable retriever interface for GraphRAG (Phase 2)
-- Steering hook for Deep Noir vectors (Phase 4)
+- Pluggable **retriever interface** for GraphRAG (Phase 2 — module ships then)
+- **Steering hook** for Deep Noir vectors (Phase 3 — module ships then)
+- Failure-class **classifier** signal consumer (routes incoming
+  classifier output to harness / GraphRAG / Deep Noir dispatchers)
+
+## 5.4 GraphRAG Memory Layer — Phase 2 first cut, hardened in Phase 3
 
-## 5.4 GraphRAG Memory Layer (Phase 2)
+**Status:** first-class deployable module. Not yet implemented; ships as a
+parallel v2 deliverable alongside Deep Noir.
 
-Persistent organisational memory — **not yet implemented.**
+Persistent organisational memory. Customers turn it on by pointing it at their
+corpus; it ingests, indexes, and serves grounded retrieval to Drydock.
 
 Sources: PDFs, Office docs, spreadsheets, markdown vaults, source code,
 ticketing exports, manuals, research papers.
@@ -250,9 +278,22 @@ ticketing exports, manuals, research papers.
 Pipeline:
 
 ```text
-ingest → parse → chunk → embed → vector index → graph links → reranker
+ingest → parse → chunk → embed → vector index → graph links → reranker → citation
 ```
 
+Drydock-side integration:
+
+- Pluggable retriever interface in the harness (so vector-only and
+  graph-augmented retrievers swap cleanly)
+- Source-priority prompt templates (retrieved evidence pinned above prior)
+- Mandatory citation in RAG flows; evaluator verifies citations resolve to
+  retrieved chunks
+- Read-before-write enforcement (§5.3) makes retrievals actually get used,
+  not bypassed in favor of the model's prior
+
+Local-only. No hosted vector DB. Embedding model and reranker run on the same
+host as vLLM.
+
 Used when:
 
 - Internal knowledge required
@@ -261,17 +302,37 @@ Used when:
 
 Operational requirement (per §10): retrieval must beat the model's prior.
 
-## 5.5 Deep Noir Layer (Phase 4)
+## 5.5 Deep Noir Activation Steering — Phase 3 first cut, deepened in Phase 4
+
+**Status:** first-class deployable module. Ships as a parallel v2 deliverable
+alongside GraphRAG.
 
 Activation-steering vectors derived from the operator's own Deep Noir research
-(see project memory). Targeted use cases:
+(see project memory). Customers select preset modes per session or per
+deployment; Drydock applies the chosen vector via vLLM's logit/activation
+hooks (or a sidecar if vLLM upstream support lags).
+
+Targeted use cases:
+
+- **Reduced-hallucination mode** — suppress "make stuff up" directions; pairs
+  well with GraphRAG citation enforcement
+- **Secure-coding mode** — suppress eval/exec/shell-injection-prone outputs
+- **Citation mode** — boost "quote source" directions in RAG flows
+- **Legal-precision / analyst / domain-bias presets** — opinionated stacks
+  for verticals
+
+Drydock-side integration:
 
-- Reduced hallucinations (suppress "make stuff up" directions)
-- Secure-coding mode (suppress eval/exec/shell-injection prone outputs)
-- Citation mode (boost "quote source" directions in RAG flows)
-- Legal-precision / analyst / domain-bias presets
+- Steering hook in the harness so the active vector is applied per request
+- Per-failure-class routing: if the classifier tags a failure as
+  steering-class, Drydock surfaces "try mode X" to the user / queues a vector
+  refinement candidate
+- Sandbox eval suite: each new vector is regression-tested against a category
+  benchmark before promotion
 
-Local-only. No hosted steering service.
+Local-only. No hosted steering service. Vectors ship with the deployment;
+retraining / refinement runs on customer hardware (per local-only-proposer
+rule).
 
 ## 5.6 Evaluator Layer
 
@@ -313,7 +374,7 @@ If no tool available:
 
 If behavior poor on a category (e.g., language interpreters):
    → surface worked example in stuck mode (already wired for tree-walking interpreter)
-   → Phase 4: apply Deep Noir vector
+   → Phase 3+: apply Deep Noir vector for that category
 
 If repeated reasoning failures across sessions:
    → recommend LoRA candidate (data captured by execution trace logging)
@@ -413,36 +474,51 @@ mitigates several of the failure classes already in `MODEL_SHORTCOMINGS.md`.
 
 # 11. Roadmap
 
-### Phase 1 — 30 days (Foundation, mostly done)
+### Phase 1 — 30 days (Foundation + perf floor)
 
 - ✅ Gemma 4 local hosting (vLLM Docker)
 - ✅ Drydock harness (v2 TUI + v3 rewrite)
 - ✅ Coding workflows + 370-PRD benchmark
 - ✅ Admiral, stress harness, autonomous review
-- ▢ **Read-before-write enforcement** (this PRD's first new build)
+- ▢ **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 (Memory)
+### Phase 2 — 60 days (Classifier + GraphRAG first cut)
 
-- ▢ GraphRAG ingestion pipeline (PDFs, code, markdown)
-- ▢ Pluggable retriever interface in Drydock
+- ▢ **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)
-- ▢ Citation-mode prompt templates
-- ▢ Operator dashboards
+- ▢ Citation-mode prompt templates + grounding eval
+- ▢ Operator dashboards (per-class failure rates over time)
 
-### Phase 3 — 90 days (Self-Improvement)
+### Phase 3 — 90 days (Deep Noir first cut + self-improvement)
 
-- ▢ Per-task evaluator with classifier (memory / retrieval / tool / steering / tune)
+- ▢ **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
 - ▢ Execution trace logging (full prompts + tool calls per task)
-- ▢ Anti-loop signal feedback into proposer
-- ▢ Autonomous upgrade loop (local-only proposer)
+- ▢ Autonomous upgrade loop (**local-only** proposer)
 - ▢ First paid pilot ($5–25K, defense-adjacent)
 
-### Phase 4 — 120 days (Steering)
+### Phase 4 — 120 days (Hardening + verticals)
 
-- ▢ Deep Noir vector pipeline
-- ▢ Domain modules (secure-coding, legal-precision, analyst, citation)
+- ▢ Deep Noir vector deepening — additional vectors driven by classifier
+  evidence (legal-precision, analyst, per-vertical bias presets)
+- ▢ GraphRAG hardening — graph-augmented retrieval, hybrid reranker,
+  ingestion freshness signals
+- ▢ Domain bundles per vertical (secure-coding, legal-precision, analyst)
 - ▢ Measured improvements on per-domain benchmarks
+- ▢ Appliance image (factory-trusted, signed updates, audit logs)
 
 ---
 

drydock_cli-2.7.30/TRIAGE_v1.md

@@ -0,0 +1,128 @@
+# Failure Triage v1 — Sovereign Stack v2 Framework, Step 2
+
+**Date:** 2026-05-02
+**Source data:** `MODEL_SHORTCOMINGS.md` (11 patterns) + `BASELINE_412.md` (32 dirty PRDs as of 2026-04-13) + open GH issues (0 at time of write).
+**Goal:** Validate the classifier taxonomy and produce a starter backlog with the right module attached to each bucket.
+
+This is a manual pass. Output of this triage drives:
+
+1. The taxonomy schema the Phase-2 classifier must be able to produce.
+2. Per-bucket evidence justifying GraphRAG and Deep Noir as first-class modules (vs. infra-on-faith).
+3. A prioritized engineering backlog by failure volume.
+
+---
+
+## Taxonomy (validated against existing data)
+
+| Bucket              | Definition                                                                          | Primary dispatcher           |
+| ------------------- | ----------------------------------------------------------------------------------- | ---------------------------- |
+| **harness**         | Tool plumbing, prompt structure, control flow, write/edit safety, loop detection.   | Drydock harness              |
+| **retrieval**       | Missing context the model has no way to know without external lookup or memory.     | GraphRAG / read-before-write |
+| **steering**        | Stable behavioral priors (direction biases) — what the model *tends* to reach for.  | Deep Noir vectors            |
+| **model-prior**     | Reasoning / world-knowledge gaps that aren't behavioral — true capability ceiling.  | LoRA fine-tune / model swap  |
+| **ambiguous-input** | PRD / user prompt is genuinely under-specified; not a model failure.                | Prompt template / ask-user   |
+
+A single failure can have a **primary** and a **secondary** bucket. The classifier's job is to emit the primary; the secondary is for prioritization.
+
+---
+
+## Per-pattern classification
+
+Mapping each `MODEL_SHORTCOMINGS.md` pattern to bucket(s):
+
+| # | Pattern (short)                                | Primary       | Secondary | Status / dispatcher                                                                             |
+| - | ---------------------------------------------- | ------------- | --------- | ----------------------------------------------------------------------------------------------- |
+| 1 | Catastrophic tool-arg malformation             | harness       | model     | ✅ mitigated (`>50%` shrink refusal, raw-code fallback in `search_replace`)                      |
+| 2 | Scaffolding without wiring                     | model-prior   | retrieval | partially mitigated by worked examples + meta_ralph; model can't trace call graphs end-to-end   |
+| 3 | Subtle logic bugs undiagnosed                  | model-prior   | steering  | "trace failing line first" steering vector candidate                                            |
+| 4 | Inheritance blindness across packages          | **retrieval** | model     | **GraphRAG candidate.** Model can't grep parent-class packages without a hint                   |
+| 5 | Regression during targeted fixes               | harness       | steering  | ✅ mitigated (snapshot + rollback in ralph_loop). Steering candidate: "minimal-patch" direction  |
+| 6 | Blindness to own stuckness                     | harness       | steering  | partially mitigated (loop detection, dedup escalation). Steering: "switch approach when stuck"  |
+| 7 | Doesn't use web_search even when enabled       | **steering**  | model     | **Deep Noir candidate.** Prompt rule alone insufficient; need to boost "search-when-stuck" dir  |
+| 8 | Hallucinated tool names                        | harness       | —         | ✅ mitigated (`_IGNORE_TOOLS` silent drop)                                                      |
+| 9 | Empty response / thinking stall                | harness       | model     | ✅ partially mitigated (truncate old tool results + thinking-stall nudge). Still seen on hard PRDs|
+| 10a| Stub-class anti-pattern                       | harness       | model     | ✅ mitigated (`_check_stub_classes` in write_file)                                              |
+| 10b| Interactive fallback with CLI args present    | model-prior   | harness   | minor; AST-check has weak signal. Steering candidate: "prefer-explicit-args" direction          |
+| 10c| Multi-module rewrites exceed 3-stage iteration| **retrieval** | model     | **GraphRAG candidate.** Need persistent design memory across sessions (~3-4 file context limit) |
+| 10 | Weak reasoning about performance / abstract   | model-prior   | steering  | "abstract reasoning" prompt + worked examples. Hard problem; possibly model-ceiling             |
+
+---
+
+## Per-bucket distribution
+
+| Bucket             | Primary count | With secondary | Comment                                                                                       |
+| ------------------ | ------------- | -------------- | --------------------------------------------------------------------------------------------- |
+| **harness**        | 6             | 8              | 5/6 already mitigated. The harness is paying its rent and continues to be the highest-volume bucket. |
+| **retrieval**      | **2**         | 4              | Cross-package inheritance + multi-module memory. **GraphRAG earns its slot** on these alone.  |
+| **steering**       | **1**         | 6              | Web-search habit is the cleanest steering candidate. Six others have steering as a viable secondary lever. **Deep Noir earns its slot.** |
+| **model-prior**    | 4             | 7              | Reasoning gaps (logic, abstract optimization, scaffolding-wiring). LoRA territory.            |
+| **ambiguous-input**| 0             | 0              | Not represented in MODEL_SHORTCOMINGS (curated for model issues). Will appear when classifier runs against live stress data. |
+
+**Headline finding:** the existing failure corpus *does* justify GraphRAG and Deep Noir as parallel v2 modules. They're not infra-on-faith — there are concrete failure patterns for each.
+
+---
+
+## Module-by-module: what the data says
+
+### Harness (already shipping; deepest investment to date)
+
+5/6 primary-harness patterns are already mitigated. The classifier still routes harness-class signals here, and the autonomous_review cron is the half-built dispatcher. **Phase-1 work:** read-before-write enforcement (will move some pattern-4 / pattern-10c-style failures from "retrieval" into "this should have been caught at write time").
+
+### GraphRAG (Phase 2 first cut — justified)
+
+Two clean primary signals:
+
+- **Pattern 4: cross-package inheritance.** Flask `request.is_xml` — model read `wrappers.py` 13× looking for a method that lives in a parent class in a different package. With a one-line hint pointing at the parent, model solved it in 61s. This is exactly what code-aware GraphRAG should serve: "where is `is_json` actually defined across the package graph?"
+- **Pattern 10c: multi-module architectural rewrites.** lang_interp's lexer→parser→type_checker→interpreter→repl chain exceeded the model's working-memory budget. Rolling design memory across sessions (PRD goals + per-module contracts + decisions made) is what GraphRAG would store.
+
+**Implication:** the GraphRAG first cut shouldn't optimize for arbitrary PDF Q&A. It should optimize for two specific shapes:
+1. **Code graph** — symbol → definition site, including parent-class chains across packages.
+2. **Project memory** — PRD + design decisions + per-module contracts, persistent across drydock sessions.
+
+This is a sharper, smaller scope than "ingest everything." Easier to ship in 60 days.
+
+### Deep Noir (Phase 3 first cut — justified)
+
+One primary signal + six viable secondaries:
+
+- **Primary: pattern 7, web-search habit.** Prompt rules don't move the needle. The model has a stable behavioral prior of "stay in local-only failure loop." A vector that boosts the "external lookup when stuck" direction is the textbook Deep Noir use case.
+- **Secondary candidates (1 vector each):**
+  - "minimal-patch direction" (pattern 5: rewrites whole file when a 3-line change would do)
+  - "switch-approach-when-stuck direction" (pattern 6: keeps trying same pattern)
+  - "prefer-explicit-args direction" (pattern 10b: ignores `--password` flag, falls to `getpass()`)
+  - "trace-failing-line direction" (pattern 3: rewrites file instead of tracing the bug)
+
+**Implication:** the Deep Noir first cut should ship **one well-tuned vector** (web-search habit) with a sandbox eval, not five vectors built in parallel. Volume of viable secondaries proves the program's value; engineering attention goes to the one with the cleanest signal first.
+
+### Model-prior (LoRA territory, longer horizon)
+
+Patterns 2, 3, 10b, 10 — reasoning gaps, not behavior gaps. Steering can move some of these (5/4 secondary on pattern 3); LoRA fine-tuning is the eventual answer. **Out of scope for v2 first cuts.** Tracked in the project `feedback_finetuning_deep_noir.md` memory.
+
+---
+
+## Pareto: what to build next, in order
+
+1. **Hosting sweep** — already queued via `*/15` cron. Locks the perf floor before classifier has any meaning.
+2. **Read-before-write enforcement** in the harness (Phase 1, already in PRD). Cheapest way to convert some pattern-4 / pattern-10c failures into clean errors before the model commits to bad output.
+3. **Classifier first cut** (Phase 2) — emits the buckets in the table above, validated against this manual pass.
+4. **Code-graph GraphRAG first cut** (Phase 2) — narrowed scope: symbol/inheritance lookup + per-project design memory. Skip arbitrary PDF Q&A in v0.
+5. **Deep Noir vector v0** (Phase 3) — single vector for the web-search habit pattern, with a sandbox eval gating promotion.
+6. Successive vectors / GraphRAG hardening as the live classifier produces volume in those buckets.
+
+---
+
+## What this triage produced
+
+- A 5-bucket taxonomy that fits all 11 documented patterns (no "other").
+- Concrete justification (with cited evidence) for both GraphRAG and Deep Noir as v2 modules.
+- A scoped first cut for each module — code-graph GraphRAG (not arbitrary corpora), single-vector Deep Noir (not five at once).
+- A prioritized backlog where engineering attention follows volume.
+- A schema for the classifier to emit. Phase-2 classifier work has a target now.
+
+---
+
+## Open questions for next pass (post-perf-baseline)
+
+- Live stress-run failures — are the failure modes the same as the curated ones? Should add ambiguous-input bucket if PRDs are under-specified at observed rates.
+- BASELINE_412 dirty PRDs — 32 packages × N tests is real failure volume. Per-PRD triage could surface patterns missing from MODEL_SHORTCOMINGS (e.g. pattern-12, pattern-13).
+- Inter-rater check — once the Phase-2 classifier is built, run it on this same data and check agreement with this manual pass. <80% agreement = taxonomy is wrong.

{drydock_cli-2.7.29 → drydock_cli-2.7.30}/drydock/core/tools/builtins/bash.py

@@ -505,16 +505,24 @@ class Bash(
                 return
 
             encoding = _get_subprocess_encoding()
-            stdout = (
-                stdout_bytes.decode(encoding, errors="replace")[:max_bytes]
-                if stdout_bytes
-                else ""
-            )
-            stderr = (
-                stderr_bytes.decode(encoding, errors="replace")[:max_bytes]
-                if stderr_bytes
-                else ""
-            )
+            stdout_raw = stdout_bytes.decode(encoding, errors="replace") if stdout_bytes else ""
+            stderr_raw = stderr_bytes.decode(encoding, errors="replace") if stderr_bytes else ""
+            if len(stdout_raw) > max_bytes:
+                stdout = stdout_raw[:max_bytes] + (
+                    f"\n[OUTPUT TRUNCATED: stdout exceeded {max_bytes} bytes. "
+                    "Use 'grep -l' to list matching files only, narrow your "
+                    "pattern, or pipe through 'head -50' to limit output. "
+                    "Do NOT re-run the same command — the result will be "
+                    "identical.]"
+                )
+            else:
+                stdout = stdout_raw
+            if len(stderr_raw) > max_bytes:
+                stderr = stderr_raw[:max_bytes] + (
+                    f"\n[STDERR TRUNCATED: exceeded {max_bytes} bytes]"
+                )
+            else:
+                stderr = stderr_raw
 
             returncode = proc.returncode or 0
 

{drydock_cli-2.7.29 → drydock_cli-2.7.30}/drydock/core/tools/builtins/read_file.py

@@ -98,25 +98,28 @@ class ReadFile(
         # pointing to the earlier tool_result. Saves context + kills the
         # "re-read 50x for no reason" pattern. Also preserves Read-before-
         # Write because the stub still counts as having read the file.
+        #
+        # Per-slot dedup: track ALL (offset, limit) combinations independently.
+        # The old single-slot approach allowed alternating offsets to bypass
+        # dedup (read offset=0, read offset=50, read offset=0 again — the
+        # offset=50 read evicted the offset=0 cache entry each time).
         read_state = ctx.read_file_state if ctx else None
         path_key = str(file_path)
         try:
             current_mtime = file_path.stat().st_mtime_ns
         except OSError:
             current_mtime = 0
-        prior = read_state.get(path_key) if read_state is not None else None
-        if (
-            prior is not None
-            and prior.get("timestamp") == current_mtime
-            and prior.get("offset") == args.offset
-            and prior.get("limit") == args.limit
-        ):
+        slot_key = (args.offset, args.limit)
+        existing_entry = read_state.get(path_key, {}) if read_state is not None else {}
+        slots: dict = existing_entry.get("_slots", {})
+        prior_slot = slots.get(slot_key)
+        if prior_slot is not None and prior_slot.get("timestamp") == current_mtime:
             # Re-embed the cached content so the model has it even if the
             # earlier tool_result was truncated by _truncate_old_tool_results.
             # Pointing at a stale/truncated prior result causes re-read loops.
-            cached_content = prior.get("content", "")
-            prior_lines = prior.get("lines_read", 0)
-            dedup_count = prior.get("dedup_count", 0)
+            cached_content = prior_slot.get("content", "")
+            prior_lines = prior_slot.get("lines_read", 0)
+            dedup_count = prior_slot.get("dedup_count", 0)
             if dedup_count == 0:
                 header = "[Unchanged since last read — content re-embedded]\n"
             else:
@@ -128,12 +131,13 @@ class ReadFile(
                     f"or move on to the next task.]\n"
                 )
             if read_state is not None:
-                read_state[path_key] = {**prior, "dedup_count": dedup_count + 1}
+                slots[slot_key] = {**prior_slot, "dedup_count": dedup_count + 1}
+                read_state[path_key] = {**existing_entry, "_slots": slots}
             yield ReadFileResult(
                 path=path_key,
                 content=f"{header}{cached_content}",
                 lines_read=prior_lines,
-                was_truncated=prior.get("was_truncated", False),
+                was_truncated=prior_slot.get("was_truncated", False),
             )
             return
 
@@ -155,7 +159,18 @@ class ReadFile(
 
         # Record read state so Write/Edit can enforce Read-before-Write
         # and so future re-reads can dedup against this one.
+        # Top-level entry (backward-compat: write_file/search_replace check
+        # read_state.get(path_key) is not None).  Per-slot entry enables
+        # independent dedup for every (offset, limit) combination so that
+        # alternating offsets can't bypass dedup.
         if read_state is not None:
+            slots[slot_key] = {
+                "content": content,
+                "timestamp": current_mtime,
+                "lines_read": len(read_result.lines),
+                "was_truncated": read_result.was_truncated,
+                "dedup_count": 0,
+            }
             read_state[path_key] = {
                 "content": content,
                 "timestamp": current_mtime,
@@ -163,6 +178,7 @@ class ReadFile(
                 "limit": args.limit,
                 "lines_read": len(read_result.lines),
                 "was_truncated": read_result.was_truncated,
+                "_slots": slots,
             }
 
         yield ReadFileResult(

{drydock_cli-2.7.29 → drydock_cli-2.7.30}/pyproject.toml

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

{drydock_cli-2.7.29 → drydock_cli-2.7.30}/tests/tools/test_bash.py

@@ -94,11 +94,22 @@ async def test_truncates_output_to_max_bytes(bash):
         bash_tool.run(BashArgs(command="printf 'abcdefghij'"))
     )
 
-    assert result.stdout == "abcde"
+    assert result.stdout.startswith("abcde")
+    assert "[OUTPUT TRUNCATED" in result.stdout
+    assert "Do NOT re-run" in result.stdout
     assert result.stderr == ""
     assert result.returncode == 0
 
 
+@pytest.mark.asyncio
+async def test_truncation_notice_absent_when_output_fits(bash):
+    # No truncation notice when output is within max_output_bytes.
+    result = await collect_result(bash.run(BashArgs(command="printf 'short'")))
+
+    assert result.stdout == "short"
+    assert "[OUTPUT TRUNCATED" not in result.stdout
+
+
 @pytest.mark.asyncio
 async def test_decodes_non_utf8_bytes(bash):
     result = await collect_result(bash.run(BashArgs(command="printf '\\xff\\xfe'")))

drydock_cli-2.7.30/tests/tools/test_read_file_dedup_alternating_offset.py

@@ -0,0 +1,109 @@
+"""Regression test: read_file dedup fires correctly when model alternates offsets.
+
+Bug: the single-slot cache (read_state[path_key]) was overwritten on every new
+(offset, limit) pair.  Reading at offset=0 stored slot A; reading at offset=50
+(empty, past EOF) overwrote slot A with slot B.  Re-reading at offset=0 then
+saw no cache hit because the slot had offset=50, triggering a fresh disk read
+and leaving the model in an infinite alternating-offset loop.
+
+Fix: track each (offset, limit) combination independently in _slots so all
+combinations are deduped regardless of read order.
+"""
+from __future__ import annotations
+
+import pytest
+from unittest.mock import MagicMock
+
+from drydock.core.tools.base import BaseToolState
+from drydock.core.tools.builtins.read_file import (
+    ReadFile,
+    ReadFileArgs,
+    ReadFileResult,
+    ReadFileToolConfig,
+)
+
+
+async def _run(tool, args, ctx) -> ReadFileResult:
+    async for event in tool.run(args, ctx):
+        if isinstance(event, ReadFileResult):
+            return event
+    raise AssertionError("no ReadFileResult yielded")
+
+
+@pytest.mark.asyncio
+async def test_alternating_offsets_both_deduped(tmp_path):
+    """offset=0 dedup survives an interleaved offset=50 read on a short file."""
+    f = tmp_path / "short.py"
+    f.write_text("line1\nline2\nline3\n")  # only 3 lines
+
+    tool = ReadFile(ReadFileToolConfig(), BaseToolState())
+    read_state: dict = {}
+    ctx = MagicMock()
+    ctx.read_file_state = read_state
+
+    args0 = ReadFileArgs(path=str(f), offset=0)
+    args50 = ReadFileArgs(path=str(f), offset=50)
+
+    # First read at offset=0 — populates cache for (0, None).
+    r1 = await _run(tool, args0, ctx)
+    assert "line1" in r1.content
+
+    # Read at offset=50 — past EOF, returns empty (or minimal) content.
+    r2 = await _run(tool, args50, ctx)
+    # Content may be empty; just ensure it doesn't crash.
+
+    # Re-read at offset=0 — MUST dedup and re-embed, NOT do a fresh disk read.
+    r3 = await _run(tool, args0, ctx)
+    assert "line1" in r3.content, "offset=0 dedup must survive interleaved offset=50 read"
+    assert "re-embedded" in r3.content or "REPEATED" in r3.content
+
+
+@pytest.mark.asyncio
+async def test_each_slot_deduped_independently(tmp_path):
+    """Each (offset, limit) slot fires dedup independently."""
+    f = tmp_path / "multi.py"
+    f.write_text("\n".join(f"line{i}" for i in range(200)) + "\n")
+
+    tool = ReadFile(ReadFileToolConfig(), BaseToolState())
+    read_state: dict = {}
+    ctx = MagicMock()
+    ctx.read_file_state = read_state
+
+    args_a = ReadFileArgs(path=str(f), offset=0, limit=50)
+    args_b = ReadFileArgs(path=str(f), offset=50, limit=50)
+
+    # First reads populate two independent slots.
+    r_a1 = await _run(tool, args_a, ctx)
+    r_b1 = await _run(tool, args_b, ctx)
+    assert "line0" in r_a1.content
+    assert "line50" in r_b1.content
+
+    # Re-read slot A after slot B — must dedup.
+    r_a2 = await _run(tool, args_a, ctx)
+    assert "line0" in r_a2.content
+    assert "re-embedded" in r_a2.content or "REPEATED" in r_a2.content
+
+    # Re-read slot B — must also dedup.
+    r_b2 = await _run(tool, args_b, ctx)
+    assert "line50" in r_b2.content
+    assert "re-embedded" in r_b2.content or "REPEATED" in r_b2.content
+
+
+@pytest.mark.asyncio
+async def test_write_file_compat_after_read(tmp_path):
+    """read_state[path_key] remains non-None after reads, so write_file can proceed."""
+    f = tmp_path / "code.py"
+    f.write_text("x = 1\n")
+
+    tool = ReadFile(ReadFileToolConfig(), BaseToolState())
+    read_state: dict = {}
+    ctx = MagicMock()
+    ctx.read_file_state = read_state
+
+    args = ReadFileArgs(path=str(f), offset=0)
+    await _run(tool, args, ctx)
+
+    # write_file checks: read_state.get(path_key) is not None
+    path_key = str(f)
+    assert read_state.get(path_key) is not None, "top-level entry must exist for write_file compat"
+    assert read_state[path_key].get("timestamp") is not None