Bound ripgrep output, isolate perf spans, and stop resume dropping blocks

The grep byte cap never bounded anything: on a breach the handler settled with
everything it had accumulated, 153 KB against a 200 byte limit in one measured
run. The notice fired, so it read as enforced. Collection now owns the bytes
behind three explicit settle points where exactly one wins, and truncates on a
line boundary.

The perf span test was not order-dependent. Every perf file cleared the store
after itself and assumed it began empty, but the store is process-global and
one process runs them all.

Resumed sessions dropped view, plan and tasks blocks with no marker. The loose
history-block shape discarded their payloads before anything could paint them.
Replaying all 49 sessions on this machine recovers 6 blocks that previously
vanished.

Author: TheGreatAxios

docs/audit-fleet-prompt.md

@@ -0,0 +1,128 @@
+# Audit fleet prompt
+
+Paste as the task for an orchestrating agent. It spawns a review panel over the
+codebase's own capabilities and reports back. Adjust the scope line before use.
+
+---
+
+You are orchestrating a standing audit of Corbits Code's own capabilities. The
+goal is not to ship a feature — it is to find out what is quietly wrong, what is
+about to break, and what has drifted from what we believe about it.
+
+**Scope for this run:** <SCOPE — e.g. "everything under src/tui-opentui and
+src/permission" or "every capability the agent exposes as a tool">
+
+## Ground rules for every agent you spawn
+
+Put these in each agent's prompt verbatim. They are not boilerplate; each one
+was bought with real time.
+
+**Read-only on git.** Do not run `git checkout`, `switch`, `stash`, `reset`,
+`clean`, `add`, `commit`, or `push`. Other agents share this working tree, and a
+`stash` has stranded work here before. Read history with `git log` / `git show
+<ref>:<path>`.
+
+**Verify by running, not by reading.** A green suite is not evidence. On this
+codebase, every genuine defect of the last cycle was found by running the app or
+capturing the pty byte stream, and every false finding came from trusting a
+document. If a claim can be executed, execute it.
+
+**Distinguish VERIFIED from SUSPECT, per finding.** A suspicion clearly labelled
+is useful. A suspicion stated as fact wastes a day and burns the reviewer's
+credibility for the findings that were real.
+
+**Do not trust documents, including ours.** A readiness doc in this repo
+recently produced four false blocking findings and a formal do-not-ship verdict;
+all four had been fixed months earlier. If a doc and the code disagree, the code
+wins, and the doc is itself a finding.
+
+**Assume tests may guard the wrong path.** We shipped a bug where the test drove
+`pushToolCall`/`pushToolResult` while the app ran `applyToolResult` — the test
+asserted correct behavior on code that never executes. When a test covers a
+finding you believe is real, check which code path it actually exercises before
+concluding the finding is wrong.
+
+**Watch for silent no-match.** Bindings, dispatch tables, and event channels
+that fail by doing nothing are this codebase's most common defect shape. We have
+found: four emitted event channels with zero listeners, five help rows
+describing behavior that did not exist, and a keybinding that never matched.
+None of them errored. None were caught by tests.
+
+## The panel — spawn these in parallel
+
+Give each its own prompt. Do not let them duplicate scope.
+
+**greybeard — architecture and the long term.** Is each abstraction sound, or
+does it encode today's decisions so tightly that the next change fights it?
+Where is ownership of a constraint split across layers, so an invariant is
+stated in one place and violated in another? What will hurt in six months?
+Explicitly ask it to separate "must fix now" from "will hurt later" — and to
+argue against large refactors close to a release, since a rewrite of the
+most-exercised file is how a good release becomes a bad week.
+
+**critique — correctness and completeness.** Find defects; do not fix them. For
+each: file, line, what breaks, and the concrete input or sequence that triggers
+it. Point it at error paths, disposal, double-dispose, resize mid-overlay, a
+source throwing mid-render, and anything whose state is valid mid-stream but
+wrong on screen.
+
+**neckbeard — hygiene, and refactor proposals.** This is the agent that files
+refactor issues. Let it be pedantic; in terminal and permission code the fiddly
+details *are* the product. Unicode width, escape sequences, off-by-ones, type
+escape hatches, boundary validation, naming and comment drift. **Explicitly
+authorize it to propose refactors as Linear issues** rather than only complain —
+one issue per proposal, with the seam it would cut along, what it buys, and what
+it risks. Require it to separate genuine defects from taste, and tell it not to
+suggest rewriting anything in Rust.
+
+**gaasbot (CTO) — risk and sequencing.** Not a code review. Given what the others
+find, what actually blocks a release, what ships with a note, and what is filed?
+Ask it directly what we are most likely getting wrong that nobody raised. Tell
+it plainly that you would rather hear "do not ship" now than at minute fifty-five.
+
+**bruckheimer — the person using it.** Not a code review either. Can a new user
+get through the first ninety seconds? Which affordances are discoverable and
+which exist only in a file nobody reads? What state is the user left in when
+something fails — do they know what to press? Read the copy actually shown on
+screen and name specific strings that should change and what they should say.
+
+## What each agent must return
+
+- Findings ranked: blocking, should-fix, file-for-later.
+- Each concrete enough for another agent to act on with no follow-up questions.
+- Evidence for anything claimed as verified — the command run, the bytes
+  captured, the frame rendered.
+- An explicit statement of what it did **not** cover, so gaps are visible rather
+  than assumed closed.
+
+Tell them a short honest review beats a padded one, and that "this is genuinely
+fine" is a useful finding when it is true.
+
+## Your job as orchestrator
+
+1. **Do not relay findings unverified.** Check the load-bearing ones yourself
+   before acting. A CTO-level verdict here rested on a stale doc; four of its
+   five blocking claims fell apart under a five-minute grep.
+2. **Dedupe across agents** — the same defect will arrive under different names.
+3. **File what is not being fixed now**, with enough context that the next
+   person does not re-derive it. An unfiled finding is a lost finding.
+4. **Route fixes to agents that own disjoint files**, and say who owns what. Two
+   agents editing one file will silently overwrite each other; that has already
+   cost a re-apply here.
+5. **Report honestly.** If the suite is red, say so with the number. If a fix is
+   mitigation rather than a fix, say which. If you were wrong earlier, correct it
+   in a sentence and move on.
+
+## Known traps in this codebase
+
+Include whichever apply to the scope:
+
+- `bun test` runs `vendor/intx-inference`; CI runs `bun test ./src ./tests
+  ./evals`. Quote the scoped number or you will report failures that do not gate.
+- Roughly forty git worktrees exist; worktree-enumerating tests fail
+  environmentally because of them.
+- The OpenTUI headless test renderer cannot see paint, real modifier reporting,
+  the system clipboard, or terminal-owned selection. Whole defect classes are
+  invisible to it by construction.
+- `Renderable.destroy()` frees only its own buffer and detaches children without
+  destroying them. Anything dropping a subtree must destroy it recursively.

src/perf/assert-spans.test.ts

@@ -16,7 +16,7 @@
  * - full observer pipeline → snapshot → rollup → assertions
  */
 
-import { afterEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import type { ReactorEmittedEvent } from "@intx/inference";
 import {
   assertLessThan,
@@ -33,6 +33,12 @@ import { ALLOWED_TAG_KEYS, clear, snapshot, type PerfSpan } from "./index.js";
 import { createPerfReactorObserver } from "./reactor-spans.js";
 import { rollupByPhase, rollupByTurn, type TurnSummary } from "./rollup.js";
 
+// The span store is process-wide, so a perf test cannot assume the tests that
+// ran before it in this process left it empty. Reset on both edges.
+beforeEach(() => {
+  clear();
+});
+
 afterEach(() => {
   clear();
 });

src/perf/index.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import {
   OPEN_SPAN_CAPACITY,
   RING_CAPACITY,
@@ -11,6 +11,12 @@ import {
   type PerfSpan,
 } from "./index.js";
 
+// The span store is process-wide, so a perf test cannot assume the tests that
+// ran before it in this process left it empty. Reset on both edges.
+beforeEach(() => {
+  clear();
+});
+
 afterEach(() => {
   clear();
 });

src/perf/otel-sink.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import type { Settings } from "../config/settings.js";
 import { clear, end, snapshot, start, type PerfSpan } from "./index.js";
@@ -13,6 +13,12 @@ import {
 } from "./otel-sink.js";
 import type { EnabledOtelExportConfig } from "./otel-config.js";
 
+// The span store is process-wide, so a perf test cannot assume the tests that
+// ran before it in this process left it empty. Reset on both edges.
+beforeEach(() => {
+  clear();
+});
+
 afterEach(() => {
   clear();
 });

src/perf/permission-subagent-spans.test.ts

@@ -1,13 +1,19 @@
 /**
  * CL-5170: permission.wait and subagent spans at the ask gate and task fleet.
  */
-import { afterEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import type { ReactorEmittedEvent } from "@intx/inference";
 import { createPermissionGate } from "../permission/gate.js";
 import { createTaskTool } from "../subagent/task-tool.js";
 import { clear, snapshot, type PerfSpan } from "./index.js";
 import { createPerfReactorObserver, currentTurnId } from "./reactor-spans.js";
 
+// The span store is process-wide, so a perf test cannot assume the tests that
+// ran before it in this process left it empty. Reset on both edges.
+beforeEach(() => {
+  clear();
+});
+
 afterEach(() => {
   clear();
 });

src/perf/reactor-spans.test.ts

@@ -1,9 +1,15 @@
-import { afterEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import type { ReactorEmittedEvent } from "@intx/inference";
 import { clear, snapshot, type PerfSpan } from "./index.js";
 import { createPerfReactorObserver } from "./reactor-spans.js";
 import { createTurnContextCollector } from "../session/hooks.js";
 
+// The span store is process-wide, so a perf test cannot assume the tests that
+// ran before it in this process left it empty. Reset on both edges.
+beforeEach(() => {
+  clear();
+});
+
 afterEach(() => {
   clear();
 });

src/perf/rollup.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdtemp, readFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -26,6 +26,12 @@ import {
   spanDurationNs,
 } from "./rollup.js";
 
+// The span store is process-wide, so a perf test cannot assume the tests that
+// ran before it in this process left it empty. Reset on both edges.
+beforeEach(() => {
+  clear();
+});
+
 afterEach(() => {
   clear();
 });

src/plugins/rg-output.test.ts

@@ -0,0 +1,72 @@
+import { test, expect } from "bun:test";
+
+import { createRgCollector } from "./rg-output.js";
+
+const line = "big.txt:1:match line here\n";
+
+test("the cap fires on the chunk that breaches it", () => {
+  const collector = createRgCollector(200);
+  expect(collector.push(line.repeat(4))).toBeUndefined();
+  expect(collector.push(line.repeat(20))).toMatchObject({
+    kind: "partial",
+    notice: expect.stringContaining("exceeded 200 bytes"),
+  });
+});
+
+test("an over-cap run reports no more than the cap, cut at a line boundary", () => {
+  const outcome = createRgCollector(200).push(line.repeat(400));
+  if (outcome?.kind !== "partial") throw new Error("expected partial");
+  expect(outcome.stdout.length).toBeLessThanOrEqual(200);
+  expect(outcome.stdout).toContain("match line here");
+  expect(outcome.stdout.endsWith("here")).toBe(true);
+});
+
+test("a cap breach outranks the exit code at every settle point", () => {
+  const overCap = (): string[] => [line.repeat(20)];
+  for (const settle of [
+    (chunks: string[]) => {
+      const c = createRgCollector(200);
+      chunks.forEach((chunk) => c.push(chunk));
+      return c.close(0, "");
+    },
+    (chunks: string[]) => {
+      const c = createRgCollector(200);
+      chunks.forEach((chunk) => c.push(chunk));
+      return c.timeout(5);
+    },
+  ]) {
+    // The cap has already settled the run, so no later path can widen it.
+    expect(settle(overCap())).toBeUndefined();
+  }
+});
+
+test("the timeout yields whatever was collected under the cap", () => {
+  const collector = createRgCollector(2_000);
+  collector.push(line);
+  expect(collector.timeout(1)).toMatchObject({
+    kind: "partial",
+    stdout: line,
+    notice: expect.stringContaining("timed out after 1ms"),
+  });
+});
+
+test("only the first settle wins", () => {
+  const collector = createRgCollector(2_000);
+  collector.push(line);
+  expect(collector.close(0, "")).toMatchObject({ kind: "output", stdout: line });
+  expect(collector.close(0, "")).toBeUndefined();
+  expect(collector.timeout(1)).toBeUndefined();
+  expect(collector.push(line.repeat(400))).toBeUndefined();
+});
+
+test("exit codes map to no-match and error", () => {
+  expect(createRgCollector(200).close(1, "")).toMatchObject({ kind: "no-match" });
+  expect(createRgCollector(200).close(2, "bad pattern")).toMatchObject({
+    kind: "error",
+    message: "bad pattern",
+  });
+  expect(createRgCollector(200).close(2, "")).toMatchObject({
+    kind: "error",
+    message: "ripgrep exited with code 2",
+  });
+});

src/plugins/rg-output.ts

@@ -0,0 +1,73 @@
+// Collects a ripgrep run's stdout and decides its outcome. `data`, `close` and
+// the timeout fire in a platform-dependent order, so the decision lives here
+// rather than in the handlers: the collector owns the accumulated bytes and
+// settles exactly once, whichever handler gets there first. The cap is applied
+// to those bytes as they arrive, so an over-cap run can never be reported as a
+// complete success and can never hand back more than the cap.
+
+export type RgOutcome =
+  | { kind: "output"; stdout: string }
+  | { kind: "no-match" }
+  | { kind: "error"; message: string }
+  | { kind: "partial"; stdout: string; notice: string };
+
+export type RgCollector = {
+  /** Returns an outcome once the cap is breached, otherwise undefined. */
+  push: (chunk: string) => RgOutcome | undefined;
+  close: (code: number | null, stderr: string) => RgOutcome | undefined;
+  timeout: (timeoutMs: number) => RgOutcome | undefined;
+};
+
+// Cutting at the cap can land mid-line; drop the trailing fragment so callers
+// never see a half-formed match.
+function truncateToWholeLines(text: string, maxBytes: number): string {
+  if (text.length <= maxBytes) return text;
+  const clipped = text.slice(0, maxBytes);
+  const lastBreak = clipped.lastIndexOf("\n");
+  return lastBreak === -1 ? clipped : clipped.slice(0, lastBreak);
+}
+
+export function createRgCollector(maxOutputBytes: number): RgCollector {
+  let stdout = "";
+  let settled = false;
+
+  const settle = (outcome: RgOutcome): RgOutcome | undefined => {
+    if (settled) return undefined;
+    settled = true;
+    return outcome;
+  };
+
+  const overCap = (): RgOutcome | undefined => {
+    if (stdout.length <= maxOutputBytes) return undefined;
+    return settle({
+      kind: "partial",
+      stdout: truncateToWholeLines(stdout, maxOutputBytes),
+      notice: `ripgrep output exceeded ${maxOutputBytes} bytes — showing partial results; narrow path/glob or pattern`,
+    });
+  };
+
+  return {
+    push: (chunk) => {
+      if (settled) return undefined;
+      stdout += chunk;
+      return overCap();
+    },
+    close: (code, stderr) => {
+      if (settled) return undefined;
+      if (code === 0) return settle({ kind: "output", stdout });
+      if (code === 1) return settle({ kind: "no-match" });
+      return settle({
+        kind: "error",
+        message: stderr.trim() || `ripgrep exited with code ${code}`,
+      });
+    },
+    timeout: (timeoutMs) => {
+      if (settled) return undefined;
+      return settle({
+        kind: "partial",
+        stdout,
+        notice: `ripgrep timed out after ${timeoutMs}ms — showing partial results; narrow path/glob`,
+      });
+    },
+  };
+}