tickmarkr 2.5.0 → 2.5.1

package/dist/adapters/fake.d.ts

@@ -25,6 +25,7 @@ export declare class FakeAdapter implements WorkerAdapter {
     private scriptPath;
     id: string;
     vendor: string;
+    busyFrameMarkers: readonly import("./types.js").BusyFrameMarker[];
     trustDialog: TrustDialog;
     private script;
     private attempts;

package/dist/adapters/fake.js

@@ -1,12 +1,13 @@
 import { readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { parseWorkerResult } from "./prompt.js";
-import { shq, TokenUsageSchema } from "./types.js";
+import { OPENCODE_BUSY_FRAME_MARKERS, shq, TokenUsageSchema } from "./types.js";
 // ponytail: deterministic scripted adapter — the whole integration suite runs on it, zero tokens.
 export class FakeAdapter {
     scriptPath;
     id = "fake";
     vendor = "fake-a";
+    busyFrameMarkers = OPENCODE_BUSY_FRAME_MARKERS;
     // v1.89 T1 / OBS-414: the scripted adapter runs `bash -c` — it has no TUI, so no prompt of any
     // kind can render. Daemon tests that exercise the auto-answer seam assign a captured declaration
     // to this field explicitly; that assignment is the falsifier for the claim made here.

package/dist/adapters/opencode.d.ts

@@ -1,3 +1,4 @@
 import { type WorkerAdapter } from "./types.js";
 export declare function parseOpencodeModels(raw: string): string[];
+export { OPENCODE_BUSY_FRAME_MARKERS } from "./types.js";
 export declare const opencode: WorkerAdapter;

package/dist/adapters/opencode.js

@@ -4,7 +4,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { probeVersion } from "./claude-code.js";
 import { parseWorkerResult } from "./prompt.js";
-import { channelsFromConfig, MODEL_ID_RE, shq, TokenUsageSchema } from "./types.js";
+import { channelsFromConfig, MODEL_ID_RE, OPENCODE_BUSY_FRAME_MARKERS, shq, TokenUsageSchema } from "./types.js";
 // v1.5 MODEL-01: pure parser for `opencode models` (one provider/model id per line, no header).
 // Live-verified 2026-07-10, opencode 1.17.15. Lines are already the seed id format; drop blanks.
 export function parseOpencodeModels(raw) {
@@ -13,9 +13,12 @@ export function parseOpencodeModels(raw) {
         .filter((l) => l.length > 0)
         .filter((id) => MODEL_ID_RE.test(id));
 }
+// Keep the adapter export available without making the fake adapter import probe code.
+export { OPENCODE_BUSY_FRAME_MARKERS } from "./types.js";
 export const opencode = {
     id: "opencode",
     vendor: "mixed",
+    busyFrameMarkers: OPENCODE_BUSY_FRAME_MARKERS,
     probeCwd: "neutral",
     probe: async () => probeVersion("opencode"),
     channels: (cfg) => channelsFromConfig("opencode", cfg),

package/dist/adapters/types.d.ts

@@ -150,6 +150,19 @@ export declare function matchesInputBox(paneText: string, inputBox: InputBox): b
 export declare function matchesEmptyInputBox(paneText: string, inputBox: InputBox): boolean;
 export declare function matchesOccupiedInputBox(paneText: string, inputBox: InputBox): boolean;
 export declare function missingInputStateDeclarations(inputBox: InputBox | undefined): string[];
+export interface BusyFrameMarker {
+    name: string;
+    match(paneText: string): boolean;
+}
+export declare const OPENCODE_BUSY_FRAME_MARKERS: readonly BusyFrameMarker[];
+export declare class SettledTrailerTracker {
+    private readonly markers;
+    private idleSamples;
+    readonly busyMarkersSeen: Set<string>;
+    settled: boolean;
+    constructor(markers: readonly BusyFrameMarker[]);
+    sample(paneText: string, trailer: boolean): boolean;
+}
 export interface WorkerAdapter {
     id: string;
     vendor: string;
@@ -174,6 +187,7 @@ export interface WorkerAdapter {
     trust?(repoRoot: string): TrustVerdict;
     trustDialog: TrustDialog;
     inputBox?: InputBox;
+    busyFrameMarkers?: readonly BusyFrameMarker[];
     hardcodedFlags?: {
         binary: string;
         flags: string[];

package/dist/adapters/types.js

@@ -207,6 +207,31 @@ export function missingInputStateDeclarations(inputBox) {
         missing.push("occupiedMatch");
     return missing;
 }
+// OBS-957 capture retained under fixtures/opencode (the captured UI identifies as omp).
+// Anchor activity glyphs to chrome/tool rows so a quoted spinner in a summary is harmless.
+export const OPENCODE_BUSY_FRAME_MARKERS = [
+    { name: "unchecked TODO", match: (text) => /(?:^|\n)[^\n]*[├└]─[^\n]*☐/.test(text) || /(?:^|\n)\s*[-*] \[ \]/.test(text) },
+    { name: "in-flight tool", match: (text) => /(?:^|\n)\s*⎋ [^\n]+/.test(text) },
+    { name: "spinner", match: (text) => /(?:^|\n)(?:[╭│][─ ]*|\s*)[⠁-⣿](?:\s|$)/.test(text) },
+];
+export class SettledTrailerTracker {
+    markers;
+    idleSamples = 0;
+    busyMarkersSeen = new Set();
+    settled = false;
+    constructor(markers) {
+        this.markers = markers;
+    }
+    sample(paneText, trailer) {
+        const busy = this.markers.filter((marker) => marker.match(paneText));
+        if (trailer)
+            for (const marker of busy)
+                this.busyMarkersSeen.add(marker.name);
+        this.idleSamples = trailer && busy.length === 0 ? this.idleSamples + 1 : 0;
+        this.settled = this.idleSamples >= 2;
+        return this.settled;
+    }
+}
 export function channelsFromConfig(adapterId, cfg) {
     const e = cfg.tiers[adapterId];
     if (!e)

package/dist/cli/commands/init.d.ts

@@ -1,3 +1,5 @@
+export type DetectedHost = "herdr" | "orca" | "subprocess";
+export declare function detectedHost(env?: NodeJS.ProcessEnv): DetectedHost;
 /** Test seam mirroring FleetIO: production callers omit it and get the process streams. */
 export type InitIO = {
     input?: NodeJS.ReadStream;

package/dist/cli/commands/init.js

@@ -4,6 +4,7 @@ import { join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
+import { parse as parseYaml } from "yaml";
 import { allAdapters, formatDoctorAgeForInit, formatDoctorReport, initDoctorReuse } from "../../adapters/registry.js";
 import { configTemplate, DEFAULT_CONFIG, globalConfigDir, loadConfig } from "../../config/config.js";
 import { LEGACY_PREFIX, specTemplate } from "../../compile/native.js";
@@ -218,7 +219,14 @@ const describeDrift = (d) => [
 // should not be asked again just because a copy drifted. Staleness is a different question with a
 // different answer (`--agent --force`), and it is reported by name on every init path below.
 const skillsInstalled = (cwd) => hostTargets(cwd).every((t) => AGENT_SKILLS.every((s) => existsSync(join(t.skillsDir, s, "SKILL.md"))));
-const wizardDriverDefault = () => process.env.HERDR_ENV === "1" ? "herdr" : orcaHostDetected() ? "orca" : "auto";
+export function detectedHost(env = process.env) {
+    if (env.HERDR_ENV === "1")
+        return "herdr";
+    if (orcaHostDetected(env))
+        return "orca";
+    return "subprocess";
+}
+const wizardDriverDefault = () => "auto";
 function packageName(cwd) {
     try {
         const parsed = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8"));
@@ -323,6 +331,7 @@ async function runInitWizard(cwd, input, output) {
             visibilityLlm: DEFAULT_CONFIG.visibility.llm,
             offerSkills: !skillsInstalled(cwd),
             skillsDefault: existsSync(join(cwd, ".claude", "skills")) && !skillsInstalled(cwd),
+            detectedHost: detectedHost(),
         },
         input,
         output,
@@ -368,8 +377,37 @@ export async function init(argv, cwd = process.cwd(), io = {}) {
     }
     const repoConfigPath = join(tickmarkrDir(cwd), "config.yaml");
     const repoConfigExists = existsSync(repoConfigPath);
-    if (repoConfigExists)
-        notes.push(`kept existing ${repoConfigPath}`);
+    if (repoConfigExists) {
+        if (values.force) {
+            const currentRaw = readFileSync(repoConfigPath, "utf8");
+            let parsedDriver;
+            try {
+                const parsed = parseYaml(currentRaw);
+                if (typeof parsed?.driver === "string")
+                    parsedDriver = parsed.driver;
+            }
+            catch {
+                // malformed: fall back to regex
+            }
+            if (!parsedDriver) {
+                const m = currentRaw.match(/^\s*driver:\s*([^\s#]+)/m);
+                if (m)
+                    parsedDriver = m[1];
+            }
+            const host = detectedHost();
+            if (parsedDriver && parsedDriver === host) {
+                const rewritten = currentRaw.replace(new RegExp(`^(\\s*driver:\\s*)${parsedDriver}\\b.*$`, "m"), `$1auto            # auto — resolves to ${host} here`);
+                writeFileSync(repoConfigPath, rewritten);
+                notes.push(`rewrote driver: ${parsedDriver} to auto in ${repoConfigPath}`);
+            }
+            else {
+                notes.push(`kept existing ${repoConfigPath}`);
+            }
+        }
+        else {
+            notes.push(`kept existing ${repoConfigPath}`);
+        }
+    }
     const specPath = join(cwd, SCAFFOLD_SPEC);
     if (existsSync(specPath)) {
         notes.push(`kept existing ${specPath}`);
@@ -417,7 +455,9 @@ export async function init(argv, cwd = process.cwd(), io = {}) {
                 // so costs one clause; everything else stops here. Esc and ctrl+c both land here.
                 return `init: wizard quit — nothing further run (scaffolding kept: ${notes.filter((n) => n.startsWith("wrote")).length} file(s) written above). Re-run tickmarkr init to continue.`;
             }
-            writeFileSync(repoConfigPath, configTemplate(wizard.overlay));
+            const host = detectedHost();
+            const renderedConfig = configTemplate(wizard.overlay).replace(/^driver: auto$/m, `driver: auto            # auto — resolves to ${host} here`);
+            writeFileSync(repoConfigPath, renderedConfig);
             notes.push(`wrote ${repoConfigPath}`);
             if (wizard.installSkills) {
                 await installAgentFiles(cwd, values.force ?? false, wizard.installDocs || (values.docs ?? false), notes);
@@ -462,7 +502,7 @@ export async function init(argv, cwd = process.cwd(), io = {}) {
     const next = nextSteps(cwd, SCAFFOLD_SPEC);
     if (!visual())
         return `${notes.join("\n")}\n${doc}\n${next}\n${ENVIRONMENTS_FOOTER}`;
-    const noteRows = notes.map((note) => `  ${statusRow(/^(?:wrote|overwrote|appended)/.test(note) ? "pass" : note.startsWith("skipped") ? "warn" : "neutral", note)}`);
+    const noteRows = notes.map((note) => `  ${statusRow(/^(?:wrote|overwrote|appended|rewrote)/.test(note) ? "pass" : note.startsWith("skipped") ? "warn" : "neutral", note)}`);
     const footerRows = ENVIRONMENTS_FOOTER.split("\n").slice(1).map((line) => {
         const separator = line.indexOf(" — ");
         return kvRow(line.slice(2, separator), line.slice(separator + 1), 12);

package/dist/cli/commands/plan.js

@@ -1,4 +1,4 @@
-import { existsSync } from "node:fs";
+import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { parseArgs } from "node:util";
 import { allAdapters, doctorAgeMs, modelAuthExclusions, probeAll, readDoctor, rolePools, servableExclusions, servabilityLine } from "../../adapters/registry.js";
@@ -7,7 +7,7 @@ import { GLYPHS, dim, rule, title, warn } from "../../brand.js";
 import { collateralLints, sourceScopeLints } from "../../compile/collateral.js";
 import { classifyContextPath } from "../../compile/native.js";
 import { DEFAULT_CONFIG, effectiveReviewPolicy, overlayPreferShapes, ROUTING_MODES, TIER_RANK } from "../../config/config.js";
-import { loadGraph } from "../../graph/graph.js";
+import { graphDefinitionHash, loadGraph, stateDirName } from "../../graph/graph.js";
 import { renderAcceptanceItem } from "../../graph/schema.js";
 import { resolveRunMode } from "../../run/daemon.js";
 import { disallowedBy, excludedChannels, exclusionLine, routingEntrySeatLines } from "../../route/preference.js";
@@ -15,7 +15,7 @@ import { staffLedEvidence } from "../../route/profile.js";
 import { route, RoutingError } from "../../route/router.js";
 import { auditNamedTestOracles, listVitestTests } from "../../gates/acceptance.js";
 import { modelId, modelProvider, pickReviewer } from "../../gates/review.js";
-import { Journal, loadRoutingProfile } from "../../run/journal.js";
+import { Journal, loadRoutingProfile, recordedGraphDefinitionHash } from "../../run/journal.js";
 import { harnessLine, resolveHarness } from "../harness.js";
 import { channelKey, shq } from "../../adapters/types.js";
 import { shGit } from "../../run/git.js";
@@ -40,7 +40,10 @@ const stylizePlan = (out) => {
 const fleetCanCrossVendorReview = (channels) => {
     for (let i = 0; i < channels.length; i++)
         for (let j = 0; j < channels.length; j++)
-            if (i !== j && channels[i].vendor !== channels[j].vendor && modelId(channels[i].model) !== modelId(channels[j].model))
+            if (i !== j
+                && channels[i].vendor !== channels[j].vendor
+                && modelProvider(channels[i].model, channels[i].vendor) !== modelProvider(channels[j].model, channels[j].vendor)
+                && modelId(channels[i].model) !== modelId(channels[j].model))
                 return true;
     return false;
 };
@@ -121,6 +124,43 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
         throw new Error(`--mode must be one of ${ROUTING_MODES.join(" | ")} (got ${values.mode})`);
     }
     const g = loadGraph(cwd);
+    const gHash = graphDefinitionHash(g);
+    const runsRoot = join(cwd, stateDirName(cwd), "runs");
+    let matchingEvents;
+    let matchingRunId;
+    if (existsSync(runsRoot)) {
+        const locked = runLockRunId(cwd);
+        const candidates = readdirSync(runsRoot)
+            .filter((d) => d.startsWith("run-") && existsSync(join(runsRoot, d, "journal.jsonl")))
+            .sort();
+        const ordered = locked && candidates.includes(locked)
+            ? [locked, ...candidates.filter((id) => id !== locked).reverse()]
+            : candidates.reverse();
+        for (const runId of ordered) {
+            try {
+                const events = Journal.open(cwd, runId).read();
+                if (recordedGraphDefinitionHash(events) === gHash) {
+                    matchingEvents = events;
+                    matchingRunId = runId;
+                    break;
+                }
+            }
+            catch {
+                // ignore unreadable or torn journals
+            }
+        }
+    }
+    const hasRun = matchingEvents !== undefined;
+    const reviewHistory = matchingEvents
+        ? matchingEvents
+            .filter((event) => event.event === "gate-result" && event.data.gate === "review" && typeof event.data.reviewer === "string")
+            .map((event) => event.data.reviewer)
+        : [];
+    // OBS-947 repair: a resumed run re-dispatches only tasks whose replayed status is pending (or that the
+    // journal never mentions). done, failed and human are all skipped alike, so rendering their preview
+    // picks must not advance the shared reviewHistory — a phantom draw wraps the LRU and makes a later
+    // pending task print the ranked-first seat while the journal's actual next draw is a later channel.
+    const taskStatuses = matchingRunId ? Journal.open(cwd, matchingRunId).replayStatuses() : new Map();
     const oracleRefusals = new Map();
     const oracleAdvisories = new Map();
     if (g.tasks.some((task) => task.acceptance.some((item) => typeof item === "object" && item.oracle === "test"))) {
@@ -306,10 +346,22 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
         const policy = effectiveReviewPolicy(task.files, cfg.review);
         if (policy === "judge-only")
             return { line: "none — reviewPolicy judge-only: declared leaf paths", cost: 0 };
-        const reviewer = pickReviewer(author, pools.review, [], cfg.review.prefer ?? [], task.routingHints?.floor);
+        let rotationSeat = 1;
+        let rotationCount = 0;
+        const reviewer = pickReviewer(author, pools.review, [], cfg.review.prefer ?? [], task.routingHints?.floor, reviewHistory, (seat, count) => { rotationSeat = seat; rotationCount = count; });
         if (!reviewer)
             return { line: "none — no cross-vendor reviewer available", cost: 0 };
-        return { line: `${channelKey(reviewer)} — reviewPolicy full`, cost: seatCost(reviewer) };
+        // Advance the simulated rotation only for tasks the run would actually dispatch next — the same
+        // rule as readyTasks (src/graph/graph.ts): pending, with every dependency already done. A pending
+        // task behind a parked/failed/pending dependency cannot run, so it consumes no draw (RULING-229-14).
+        const isPending = (id) => { const s = taskStatuses.get(id); return s === undefined || s === "pending"; };
+        const ready = isPending(task.id) && task.deps.every((d) => taskStatuses.get(d) === "done");
+        if (hasRun && ready)
+            reviewHistory.push(channelKey(reviewer));
+        const rotationNote = rotationCount > 1
+            ? (hasRun ? ` (seat ${rotationSeat} of ${rotationCount})` : ` (seat 1 of ${rotationCount} — rotation applies at run time)`)
+            : "";
+        return { line: `${channelKey(reviewer)}${rotationNote} — reviewPolicy full`, cost: seatCost(reviewer) };
     };
     const routed = [];
     for (const t of g.tasks) {

package/dist/cli/commands/report.js

@@ -268,7 +268,9 @@ export function renderMarkdownRecord(runId, events, prices = [], rows = []) {
                         pass = "pass (same-provider — independence not established)";
                     }
                 }
-                lines.push(`  - ${gate}: ${pass} — ${firstLine(g.data.details)}`);
+                const resolved = gate === "review" && g.data.pass === true && Array.isArray(g.data.resolved)
+                    ? g.data.resolved.filter((id) => typeof id === "string") : [];
+                lines.push(`  - ${gate}: ${pass} — ${firstLine(g.data.details)}${resolved.length ? `; resolved: ${resolved.join(", ")}` : ""}`);
             }
             for (const row of leg2) {
                 const pass = row.data.pass === true ? "pass" : row.data.pass === false ? "fail" : EM;

package/dist/cli/commands/run.js

@@ -118,6 +118,9 @@ export const RAIL_ROWS = {
     "gate-result": { label: "gate", tone: "pass" },
     "gate-reused": { label: "gate reused", tone: "neutral" },
     "judge-retry": { label: "judge retry", tone: "attention" },
+    "review-no-verdict": { label: "review unavailable", tone: "attention" },
+    "review-pool-demotion": { label: "review seat demoted", tone: "attention" },
+    "review-infra-retry": { label: "review infra retry", tone: "attention" },
     "review-retry": { label: "review retry", tone: "attention" },
     // repairs and escalations
     "repair-dispatch": { label: "repair", tone: "attention" },

package/dist/gates/llm.d.ts

@@ -61,7 +61,12 @@ export interface LlmRunResult {
     output: string;
     exitCode?: number;
     timedOut: boolean;
+    launchNeverStarted?: boolean;
+    seatAuthoredBytes?: number;
 }
+export declare const PROMPT_GLYPHS: readonly ["➜", "❯", "$", "%", ">>", ">"];
+export declare function reviewSeatOutput(raw: string, nonce: string): string;
+export declare const REVIEW_FIRST_LIVENESS_MS = 30000;
 export declare function runHeadless(adapter: WorkerAdapter, model: string, prompt: string, cwd: string, timeoutMs?: number): Promise<string>;
 export declare function runViaDriver(adapter: WorkerAdapter, model: string, prompt: string, cwd: string, via: LlmVia, timeoutMs?: number): Promise<string>;
 export declare function dewrapPaneVerdict(out: string, nonce: string): string;

package/dist/gates/llm.js

@@ -1,3 +1,4 @@
+import { stripVTControlCharacters } from "node:util";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { randomBytes } from "node:crypto";
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
@@ -5,7 +6,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { matchesTrustDialog } from "../adapters/types.js";
 import { formatOwnedName, parseOwnedName } from "../drivers/types.js";
-import { bannerShell, paneDispatchCommand } from "../brand.js";
+import { bannerShell, paneDispatchCommand, PLAIN_BANNER } from "../brand.js";
 import { sh } from "../run/git.js";
 import { harvestCpuFlatWindowMs, normalizeStallSnapshot, WorkerTreeCpuAccountant, } from "../run/stall.js";
 export const GATE_PANE_SEP = " · ";
@@ -129,13 +130,164 @@ export async function captureLlmOutput(run) {
     const value = await llmOutputCapture.run(outputs, run);
     return { value, outputs };
 }
+// The harness preamble has a fixed row shape, in order: the dispatch echo rows (the identity export
+// and the START printf, each possibly re-echoed behind the shell prompt), the START acknowledgement
+// row, the banner rows, blank rows, and the identity row. RULING-229-15 add.1 makes the boundary
+// STRUCTURAL: a pane read is line-terminated, so only the LAST row of a capture can be a partial
+// paint. Every row before it is complete, and a complete row is harness only when it EQUALS a full
+// harness row in the position the preamble allows. A complete row that merely starts with "T",
+// "export", "review" or a banner glyph is seat text, and seat prose that MENTIONS a marker mid-row
+// counts in full — "contains TICKMARKR_START_ somewhere" is never by itself a reason to measure zero.
+const BANNER_ROWS = PLAIN_BANNER.replace(/\n$/, "").split("\n");
+const ECHO_OPENER = "export HERDR_WORKSPACE_ID=";
+const ECHO_START_OPENER = "printf '%s%s\\n' 'TICKMARKR_START_' '";
+const ECHO_OPENERS = [ECHO_OPENER, ECHO_START_OPENER];
+// RULING-229-15 add.5: the prompt glyph set is this CLOSED list — the corpus sweeps it, the grammar
+// consumes the LONGEST glyph that matches (so ">>" is one glyph and ">" is still one).
+export const PROMPT_GLYPHS = ["➜", "❯", "$", "%", ">>", ">"];
+const GIT_SEGMENT_OPEN = "git:(";
+function echoRowMatch(row) {
+    const opener = (at) => {
+        const body = row.slice(at);
+        if (ECHO_OPENERS.some((o) => body.startsWith(o)))
+            return "complete";
+        return ECHO_OPENERS.some((o) => o.startsWith(body)) ? "partial" : "none";
+    };
+    const ws = (at) => /^\s+/.exec(row.slice(at))?.[0].length;
+    const bare = opener(0);
+    if (bare !== "none")
+        return bare;
+    const glyph = PROMPT_GLYPHS.find((g) => row.startsWith(g));
+    if (glyph === undefined)
+        return "none";
+    let i = glyph.length;
+    const ws1 = ws(i);
+    if (ws1 === undefined)
+        return row.length === i ? "partial" : "none";
+    i += ws1;
+    const dir = /^\S+/.exec(row.slice(i));
+    if (!dir)
+        return "partial";
+    i += dir[0].length;
+    const ws2 = ws(i);
+    if (ws2 === undefined)
+        return "partial";
+    i += ws2;
+    const rest = row.slice(i);
+    if (rest.startsWith(GIT_SEGMENT_OPEN)) {
+        const close = row.indexOf(")", i + GIT_SEGMENT_OPEN.length);
+        if (close < 0)
+            return "partial";
+        i = close + 1;
+        const ws3 = ws(i);
+        if (ws3 === undefined)
+            return row.length === i ? "partial" : "none";
+        return opener(i + ws3);
+    }
+    if (GIT_SEGMENT_OPEN.startsWith(rest))
+        return "partial"; // "", "g", "gi", "git", "git:"
+    return opener(i);
+}
+// A complete dispatch echo row: the grammar reaches the opener. Never "contains the opener" — a row
+// that mentions it mid-prose is the seat's.
+function completeEchoRow(row) {
+    return echoRowMatch(row) === "complete";
+}
+// A LAST row still being painted: any prefix of a row in the grammar.
+function partialEchoRow(row) {
+    return echoRowMatch(row) !== "none";
+}
+const START_MARKER = "TICKMARKR_START_";
+const START_ROW = /^TICKMARKR_START_[\w-]+$/;
+const IDENTITY_LINE = /^(?:review\s*·|tickmarkr(?::|$))/;
+const IDENTITY_OPENERS = ["review ·", "tickmarkr"];
+// Stages of the preamble walk. Each complete harness row is accepted only at or after its stage.
+const ECHO = 0, START = 1, BANNER = 2, IDENTITY = 3, SEAT = 4;
+// The char offset where the seat's own text begins, or -1 when the capture ends inside the preamble.
+function seatStart(output) {
+    const rows = output.split("\n");
+    if (rows.length > 1 && rows[rows.length - 1] === "")
+        rows.pop(); // the read's own line terminator
+    let stage = ECHO;
+    let bannerAt; // next banner row expected once the banner has begun
+    let offset = 0;
+    for (let i = 0; i < rows.length; i++) {
+        const row = rows[i].replace(/[ \t]+$/, "");
+        const t = row.trim();
+        const last = i === rows.length - 1;
+        // Complete harness rows: equality against the shape the preamble allows at this stage.
+        let accepted = false;
+        if (stage < SEAT && t.length === 0)
+            accepted = true; // blank rows between preamble rows
+        else if (stage <= ECHO && completeEchoRow(row))
+            accepted = true;
+        else if (stage <= START && START_ROW.test(row)) {
+            stage = BANNER;
+            accepted = true;
+        }
+        else if (stage <= BANNER && bannerAt === undefined && BANNER_ROWS.includes(row)) {
+            stage = BANNER;
+            bannerAt = BANNER_ROWS.indexOf(row) + 1;
+            accepted = true;
+        }
+        else if (stage <= BANNER && bannerAt !== undefined && row === BANNER_ROWS[bannerAt]) {
+            bannerAt++;
+            accepted = true;
+        }
+        else if (stage <= IDENTITY && IDENTITY_LINE.test(t)) {
+            stage = SEAT;
+            accepted = true;
+        }
+        if (accepted) {
+            offset += rows[i].length + 1;
+            continue;
+        }
+        if (!last)
+            return offset;
+        // The last row may be a partial paint: a prefix of the next harness row the preamble allows.
+        if (stage <= ECHO && partialEchoRow(row))
+            return -1;
+        if (stage <= START && (START_MARKER.startsWith(row) || /^TICKMARKR_START_[\w-]*$/.test(row)))
+            return -1;
+        if (stage <= BANNER && (bannerAt === undefined
+            ? BANNER_ROWS.some((b) => b.startsWith(row))
+            : BANNER_ROWS[bannerAt]?.startsWith(row) === true))
+            return -1;
+        // The identity row is painted right after the banner, so its prefix is a partial paint only there;
+        // with no banner in the capture, "review" or "tick" alone is the seat's own first row.
+        if (stage <= IDENTITY && bannerAt === BANNER_ROWS.length && IDENTITY_OPENERS.some((o) => o.startsWith(t)))
+            return -1;
+        return offset;
+    }
+    return -1; // every row was harness — the seat has not taken its turn
+}
+// A pane's dispatch echo, start acknowledgement, banner and identity are harness bytes.
+// Remove only that leading preamble, never matching text later in the seat's response.
+// Every capture taken before the preamble finishes therefore measures ZERO seat-authored bytes,
+// which is what makes the caller's running Math.max safe: a partial banner counted once would be
+// retained for the whole call and buy a silent seat its full ceiling.
+export function reviewSeatOutput(raw, nonce) {
+    const output = stripVTControlCharacters(raw).replace(/\r\n?/g, "\n");
+    const start = seatStart(output);
+    if (start < 0)
+        return "";
+    const seat = output.slice(start);
+    // Anything after the nonce-bound trailer belongs to the terminal (typically the next shell
+    // prompt), not the reviewer. Deleting only the marker would count that postlude as seat output and
+    // let a zero-byte seat escape first-silence demotion.
+    const trailer = new RegExp(`(?:^|\\n)TICKMARKR_EXIT_${nonce}:\\d+[^\\n]*(?:\\n|$)`).exec(seat);
+    // A trailer row still being typed is not stripped: after the preamble a last row "T" is far more
+    // often the seat's first byte than the harness's exit marker, and the next read completes either.
+    return trailer ? seat.slice(0, trailer.index) : seat;
+}
+export const REVIEW_FIRST_LIVENESS_MS = 30_000;
 async function runHeadlessDetailed(adapter, model, prompt, cwd, timeoutMs = 300000) {
     const dir = mkdtempSync(join(tmpdir(), "tickmarkr-llm-"));
     try {
         const pf = join(dir, "prompt.md");
         writeFileSync(pf, prompt);
         const r = await sh(adapter.headlessCommand(pf, model), cwd, timeoutMs);
-        return { output: r.stdout + "\n" + r.stderr, exitCode: r.code, timedOut: r.timedOut === true };
+        return { output: r.stdout + "\n" + r.stderr, exitCode: r.code, timedOut: r.timedOut === true, seatAuthoredBytes: Buffer.byteLength(r.stdout + r.stderr) };
     }
     finally {
         rmSync(dir, { recursive: true, force: true });
@@ -150,6 +302,7 @@ async function runViaDriverDetailed(adapter, model, prompt, cwd, via, timeoutMs
     const dir = mkdtempSync(join(tmpdir(), "tickmarkr-llm-"));
     let slot;
     let accountant;
+    let forceClose = false;
     try {
         const pf = join(dir, "prompt.md");
         writeFileSync(pf, prompt);
@@ -180,6 +333,8 @@ async function runViaDriverDetailed(adapter, model, prompt, cwd, via, timeoutMs
         const exitPattern = `TICKMARKR_EXIT_${nonce}:\\d`;
         let out;
         let timedOut = false;
+        let launchNeverStarted = false;
+        let seatAuthoredBytes = 0;
         const gatePrompt = prompt.startsWith("TICKMARKR-JUDGE") || prompt.startsWith("TICKMARKR-REVIEW");
         if (!gatePrompt) {
             await via.driver.waitOutput(slot, exitPattern, timeoutMs, { regex: true });
@@ -193,6 +348,9 @@ async function runViaDriverDetailed(adapter, model, prompt, cwd, via, timeoutMs
             await accountant.start();
             const startedAt = Date.now();
             out = await via.driver.read(slot, 400);
+            const reviewing = prompt.startsWith("TICKMARKR-REVIEW");
+            seatAuthoredBytes = Buffer.byteLength(reviewSeatOutput(out, nonce));
+            let firstLivenessObserved = false;
             let priorSnapshot = normalizeStallSnapshot(out);
             const anchoredAt = Date.now();
             let quietSince = anchoredAt;
@@ -207,12 +365,35 @@ async function runViaDriverDetailed(adapter, model, prompt, cwd, via, timeoutMs
                 const matched = await via.driver.waitOutput(slot, exitPattern, sliceMs, { regex: true });
                 const raw = await via.driver.read(slot, 400);
                 out = raw;
+                seatAuthoredBytes = Math.max(seatAuthoredBytes, Buffer.byteLength(reviewSeatOutput(raw, nonce)));
                 // waitOutput is the driver's authoritative marker match. The raw check covers drivers whose
                 // wait timed out at the same boundary the marker landed; either way a trailer completes
                 // normally and is never mistaken for inactivity.
                 if (matched || new RegExp(exitPattern).test(raw))
                     break;
                 const now = Date.now();
+                // The ceiling wins if it coincides with the first beat (or the read crosses it).
+                // That seat was killed by its configured timeout, not an early launch reroute.
+                if (now - startedAt >= timeoutMs)
+                    break;
+                if (reviewing && !firstLivenessObserved && now - startedAt >= REVIEW_FIRST_LIVENESS_MS) {
+                    firstLivenessObserved = true;
+                    // RS-2: the beat reads seat-authored bytes ALONE. CPU evidence never holds a preamble-only
+                    // capture open to the ceiling; a seat that has not written one byte of its own is re-routed.
+                    // OBS-944 is why a buffering runner earns no exemption here: the claude-code seat's 901 s
+                    // capture was byte-identical across two legs and ended at the pane-identity line — that
+                    // seat never started, it was not quietly working. RULING-229-06 puts the beat on the PANE
+                    // path only; a headless `-p` runner (runHeadlessDetailed, no pane, no beat) buffers every
+                    // byte until completion and keeps its full ceiling.
+                    if (seatAuthoredBytes === 0) {
+                        launchNeverStarted = true;
+                        forceClose = true;
+                        break;
+                    }
+                }
+                // Producing reviews own their full ceiling; inactivity is not a review verdict.
+                if (reviewing)
+                    continue;
                 const snapshot = normalizeStallSnapshot(raw);
                 if (snapshot !== priorSnapshot) {
                     priorSnapshot = snapshot;
@@ -246,18 +427,22 @@ async function runViaDriverDetailed(adapter, model, prompt, cwd, via, timeoutMs
                 }
             }
             timedOut = Date.now() - startedAt >= timeoutMs && !new RegExp(exitPattern).test(out);
+            if (timedOut)
+                forceClose = true;
         }
         const exitCode = Number(new RegExp(`TICKMARKR_EXIT_${nonce}:(\\d+)`).exec(out)?.[1]);
         return {
             output: dewrapPaneVerdict(out, nonce),
             ...(Number.isFinite(exitCode) ? { exitCode } : {}),
             timedOut,
+            launchNeverStarted,
+            seatAuthoredBytes,
         };
     }
     finally {
         try {
             await accountant?.stop();
-            if (slot && !via.keep)
+            if (slot && (forceClose || !via.keep))
                 await via.driver.close(slot);
         }
         finally {