tickmarkr 2.8.2 → 2.8.4

package/dist/adapters/claude-code.js

@@ -238,6 +238,9 @@ export const claudeCode = {
     // The empty -p argument selects print mode while stdin carries the prompt, keeping its nonce out
     // of process argv. The redirect path is shell-quoted independently from the model.
     headlessCommand: (promptFile, model, effort) => `claude -p '' --model ${shq(model)}${claudeEffortFlag(effort)} --permission-mode bypassPermissions --strict-mcp-config --mcp-config '{"mcpServers":{}}' --output-format text < ${shq(promptFile)}`,
+    // Queue row 184: `--output-format text` prints nothing until the turn ends, so a working pane reviewer reads zero seat bytes at
+    // the first-liveness beat; the beat must not re-route it (2.8.3 killed every claude pane reviewer at 30 s).
+    paneReviewBuffersOutput: true,
     // HYG-03 / OBS-137: the residual first-entry dialog is workspace trust, not MCP config loading.
     // Claude's only store is global last-writer-wins ~/.claude.json, so tickmarkr still does not seed it;
     // the daemon safely answers only the exact adapter-declared dialog once per slot.

package/dist/adapters/kimi.js

@@ -1,3 +1,4 @@
+import { spawnSync } from "node:child_process";
 import { readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -171,7 +172,32 @@ export function confirmKimiSeedBanner(banner, assignedModel) {
     }
     return { ok: true, status: "confirmed", ...(sessionId === undefined ? {} : { sessionId }) };
 }
-const kimiTuiLaunch = (model) => `kimi -y -m ${shq(model)}`;
+const KIMI_HELP_TIMEOUT_MS = 10_000;
+function kimiHasNeverAskOption(help) {
+    let inOptions = false;
+    for (const line of help.split(/\r?\n/)) {
+        if (line === "Options:") {
+            inOptions = true;
+            continue;
+        }
+        if (inOptions && /^[^\s].*:$/.test(line))
+            break;
+        if (inOptions && /^  --auto[ \t]{2,}Start in Never Ask mode\b/.test(line))
+            return true;
+    }
+    return false;
+}
+const kimiTuiLaunch = (model) => {
+    let neverAsk = false;
+    try {
+        const help = spawnSync("kimi", ["--help"], {
+            encoding: "utf8", timeout: KIMI_HELP_TIMEOUT_MS, stdio: ["ignore", "pipe", "ignore"],
+        });
+        neverAsk = !help.error && help.status === 0 && kimiHasNeverAskOption(help.stdout);
+    }
+    catch { /* unreadable help keeps the existing launch form */ }
+    return `kimi ${neverAsk ? "--auto" : "-y"} -m ${shq(model)}`;
+};
 const KIMI_ANSI_SGR_RE = /\u001B\[[0-9;]*m/g;
 const KIMI_EDITOR_TOP_RE = /^╭─+╮$/;
 const KIMI_EDITOR_INPUT_RE = /^│ > .*│$/;
@@ -215,7 +241,10 @@ export const KIMI_INPUT_BOX = declareInputBox("kimi", {
     fingerprint: "│ > ",
     match: (paneText) => matchesKimiEditorBox(paneText, false),
     emptyMatch: (paneText) => matchesKimiEditorBox(paneText, true),
-    launchCommand: (command) => command.startsWith("kimi -y -m "),
+    launchCommand: (command) => {
+        const match = /^kimi (?:--auto|-y) -m '([^']+)'$/.exec(command);
+        return match !== null && MODEL_ID_RE.test(match[1]);
+    },
     readinessTimeoutMs: 15_000,
 });
 // Shared launch-then-seed surface (T6) + banner confirm (T7/T2). One definition so the adapter

package/dist/adapters/qwen.d.ts

@@ -1,6 +1,6 @@
 import { type ClassifiedWorkerResult } from "./prompt.js";
 import { type WorkerAdapter } from "./types.js";
 export declare const QWEN_VERSION_IDENTITY: RegExp;
-export declare const QWEN_HARNESS_BANNER_ROWS: readonly ["⚠ SAFE MODE — all customizations disabled (hooks, extensions, skills, MCP servers, QWEN.md). Restart without --safe-mode to resume normal operation.", "Warning: running headless with --yolo / approval-mode=yolo and no sandbox. All tool calls (shell, write, edit) auto-execute at this process's privilege level. Enable a sandbox via --sandbox / QWEN_SANDBOX, or set QWEN_CODE_SUPPRESS_YOLO_WARNING=1 to silence this notice."];
+export declare const QWEN_HARNESS_BANNER_ROWS: readonly ["⚠ SAFE MODE — all customizations disabled (hooks, extensions, skills, MCP servers, QWEN.md). Restart without --safe-mode to resume normal operation.", "Warning: running headless with --yolo / approval-mode=yolo and no sandbox. All tool calls (shell, write, edit) auto-execute at this process's privilege level. Enable a sandbox via --sandbox / QWEN_SANDBOX, or set QWEN_CODE_SUPPRESS_YOLO_WARNING=1 to silence this notice.", "Warning: running headless with --yolo / approval-mode=yolo and no sandbox. All tool calls (shell, write, edit) auto-execute at this process's privilege level. Configure tools.executionSandbox on Linux or a supported legacy sandbox via --sandbox / QWEN_SANDBOX, or set QWEN_CODE_SUPPRESS_YOLO_WARNING=1 to silence this notice."];
 export declare function parseQwenResult(raw: string, nonce: string): ClassifiedWorkerResult;
 export declare const qwen: WorkerAdapter;

package/dist/adapters/qwen.js

@@ -3,12 +3,14 @@ import { parseWorkerResult } from "./prompt.js";
 import { channelsFromConfig, shq, } from "./types.js";
 export const QWEN_VERSION_IDENTITY = /^\d+\.\d+\.\d+/;
 const QWEN_SKIP_UPDATE = "QWEN_CODE_SKIP_UPDATE_CHECK_ONCE=true";
-// Verbatim stderr from tests/fixtures/qwen/safe-mode.stderr (qwen 0.21.15). These bytes are launch
-// harness, not evidence that a reviewer took a turn. Keep the declaration closed and row-shaped so
-// llm.ts can sweep partial terminal paints without a broad SAFE MODE/warning regex.
+// Verbatim stderr rows, in render order: the SAFE MODE row both recorded versions print, then the yolo
+// row of tests/fixtures/qwen/safe-mode.stderr (qwen 0.21.15) and of safe-mode-0.25.1.stderr (qwen 0.25.1).
+// These bytes are launch harness, not evidence that a reviewer took a turn. Keep the declaration closed
+// and row-shaped so llm.ts can sweep partial terminal paints without a broad SAFE MODE/warning regex.
 export const QWEN_HARNESS_BANNER_ROWS = [
     "⚠ SAFE MODE — all customizations disabled (hooks, extensions, skills, MCP servers, QWEN.md). Restart without --safe-mode to resume normal operation.",
     "Warning: running headless with --yolo / approval-mode=yolo and no sandbox. All tool calls (shell, write, edit) auto-execute at this process's privilege level. Enable a sandbox via --sandbox / QWEN_SANDBOX, or set QWEN_CODE_SUPPRESS_YOLO_WARNING=1 to silence this notice.",
+    "Warning: running headless with --yolo / approval-mode=yolo and no sandbox. All tool calls (shell, write, edit) auto-execute at this process's privilege level. Configure tools.executionSandbox on Linux or a supported legacy sandbox via --sandbox / QWEN_SANDBOX, or set QWEN_CODE_SUPPRESS_YOLO_WARNING=1 to silence this notice.",
 ];
 function decodeQwenEvents(events) {
     const text = [];

package/dist/adapters/types.d.ts

@@ -195,6 +195,7 @@ export interface WorkerAdapter {
     channels(cfg: TickmarkrConfig): BillingChannel[];
     headlessCommand(promptFile: string, model: string, effort?: Effort): string;
     harnessBannerRows?: readonly string[];
+    paneReviewBuffersOutput?: boolean;
     interactiveCommand(promptFile: string, model: string, effort?: Effort): string | null;
     interactiveSeed?: InteractiveSeed;
     resumeCommand?(sessionId: string, promptFile: string, model: string, effort?: Effort): string;

package/dist/cli/commands/approve.js

@@ -1,4 +1,5 @@
 import { graphDefinitionHash, loadGraph, saveGraph, taskDefinitionFingerprint } from "../../graph/graph.js";
+import { filesGlob } from "../../graph/files-glob.js";
 import { execFileSync } from "node:child_process";
 import { userInfo } from "node:os";
 import { allAdapters } from "../../adapters/registry.js";
@@ -242,7 +243,7 @@ export async function approve(argv, cwd = process.cwd()) {
             if (amendedFiles.length === task.files.length)
                 throw new Error("--files must extend the parked files[] revision");
             const amended = { ...graph, tasks: graph.tasks.map((t) => t.id === taskId ? { ...t, files: amendedFiles } : t) };
-            const conflicts = separabilityErrors(amended.tasks);
+            const conflicts = scopeGrantConflicts(cwd, journal, runId, taskId, amended.tasks, events);
             if (conflicts.length)
                 throw new Error(`refusing scope-request approval for ${taskId}: ${conflicts.join("\n")}`);
             // C4: a live grant may not take a task past the bounds that fail every compile. The exception
@@ -394,6 +395,110 @@ function integrationBase(events, byName) {
     const branch = String(events.find((e) => e.event === "run-start").data.branch);
     return "anchor" in anchor ? { branch, base: anchor.anchor } : { branch, base: "unknown", unreadable: anchor.unreadable };
 }
+/**
+ * Queue 169 (D-1982/D-1983/D-1986): the in-run OBS-212 check a scope-request grant runs. Only the
+ * pairs this amendment changes are judged — the requester against each unordered sibling; a pair
+ * another amendment created was judged by that grant and is never re-judged here. A sibling is
+ * exempt only when this run already merged it into the requester's branch: its replayed status is
+ * done, its NEWEST journaled merge row names a full lowercase object id, and that commit is an
+ * ancestor of the requester's task branch (the run's integration branch plus --taskId, read exactly
+ * as the failed-task recheck reads it — a marked run's branch comes from its run-start record, never
+ * the current config). Every other overlapping pair keeps the compile-time refusal, an unreadable
+ * git answer included. The surviving errors are separabilityErrors' own rows, so the refusal text
+ * and its pair order are unchanged.
+ */
+function scopeGrantConflicts(cwd, journal, runId, requesterId, tasks, events) {
+    const errors = separabilityErrors(tasks);
+    if (!errors.length)
+        return errors;
+    const pairs = separabilityPairs(tasks);
+    if (pairs.length !== errors.length)
+        return errors; // a misaligned local fold refuses everything
+    const statuses = journal.replayStatuses();
+    let taskRef;
+    const requesterRef = () => (taskRef ??= `${integrationBase(events, () => integrationBranch(loadConfig(cwd), runId)).branch}--${requesterId}`);
+    const kept = [];
+    for (let i = 0; i < errors.length; i++) {
+        const { a, b } = pairs[i];
+        const sibling = a === requesterId ? b : b === requesterId ? a : undefined;
+        if (sibling === undefined)
+            continue;
+        if (mergedSiblingExempt(cwd, events, statuses.get(sibling), sibling, requesterRef))
+            continue;
+        kept.push(errors[i]);
+    }
+    return kept;
+}
+/** A full lowercase git object id: 40 (SHA-1) or 64 (SHA-256) hex, nothing else. */
+const FULL_OBJECT_ID = /^[0-9a-f]{40}([0-9a-f]{24})?$/;
+/**
+ * The one exemption: the sibling is done in THIS run's replay and its newest merge row's commit is a
+ * full object id that is an ancestor of the requester's task branch. Any unreadable git answer — a
+ * missing requester branch, a commit the repository lacks, a failed ancestry read — is no exemption.
+ */
+function mergedSiblingExempt(cwd, events, status, siblingId, requesterRef) {
+    if (status !== "done")
+        return false;
+    const merge = [...events].reverse().find((e) => e.event === "merge" && e.taskId === siblingId);
+    const commit = typeof merge?.data.commit === "string" ? merge.data.commit : undefined;
+    if (commit === undefined || !FULL_OBJECT_ID.test(commit))
+        return false;
+    const ref = requesterRef();
+    try {
+        execFileSync("git", ["rev-parse", "--verify", ref], { cwd, stdio: "ignore" });
+        execFileSync("git", ["merge-base", "--is-ancestor", commit, ref], { cwd, stdio: "ignore" });
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
+/** The conflicting unordered pairs of separabilityErrors, in its exact emission order. */
+function separabilityPairs(tasks) {
+    const byId = new Map(tasks.map((t) => [t.id, t.deps ?? []]));
+    const pairs = [];
+    for (let i = 0; i < tasks.length; i++) {
+        for (let j = i + 1; j < tasks.length; j++) {
+            const a = tasks[i], b = tasks[j];
+            if (pairReachable(a.id, byId).has(b.id) || pairReachable(b.id, byId).has(a.id))
+                continue; // ordered
+            if (pairOverlap(a.files ?? [], b.files ?? []).length > 0)
+                pairs.push({ a: a.id, b: b.id });
+        }
+    }
+    return pairs;
+}
+/** Tasks reachable from `id` through deps (transitive) — separabilityErrors' own fold. */
+function pairReachable(id, byId) {
+    const seen = new Set();
+    const stack = [...(byId.get(id) ?? [])];
+    while (stack.length) {
+        const next = stack.pop();
+        if (seen.has(next))
+            continue;
+        seen.add(next);
+        stack.push(...(byId.get(next) ?? []));
+    }
+    return seen;
+}
+/** separabilityErrors' conservative overlap: identical patterns, or a glob matching the other's literal path. */
+function pairOverlap(a, b) {
+    const hits = new Set();
+    const isGlob = (p) => /[*?[\]{}]/.test(p);
+    for (const pa of a) {
+        for (const pb of b) {
+            if (pa === pb) {
+                hits.add(pa);
+                continue;
+            }
+            if (isGlob(pa) && !isGlob(pb) && filesGlob(pa)(pb))
+                hits.add(`${pb} ⊂ ${pa}`);
+            else if (isGlob(pb) && !isGlob(pa) && filesGlob(pb)(pa))
+                hits.add(`${pa} ⊂ ${pb}`);
+        }
+    }
+    return [...hits].sort();
+}
 /** The row a decision on this task answers right now: its newest failure when failed, else its newest park. */
 function openDecision(journal, taskId) {
     const { events, sourceIndexes } = readJournalEvents(journal);

package/dist/gates/acceptance.js

@@ -1,11 +1,13 @@
-import { readdirSync } from "node:fs";
-import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { lstatSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { isAbsolute, join, relative, resolve } from "node:path";
 import { z } from "zod";
 import { channelKey, shq } from "../adapters/types.js";
 import { compileNative } from "../compile/native.js";
 import { DEFAULT_DIFF_CAP } from "../config/config.js";
 import { renderAcceptanceItem } from "../graph/schema.js";
-import { sh } from "../run/git.js";
+import { DEFAULT_SHELL_TIMEOUT_MS, sh, shell } from "../run/git.js";
 import { checkTaskDiffCaps, fetchTaskDiff, isProtectedEvidence, setAsideReceiptPath } from "./review.js";
 import { appendAnchoredReview, COMPLETION_FAKING_CHECKLIST, extractVerdictJson, generateVerdictNonce, runLlm, SeatLaunchError, verdictNonceLine } from "./llm.js";
 import { classifyVerdictCause } from "./verdict-cause.js";
@@ -13,6 +15,8 @@ import { reviewableLogicDiff } from "./artifact-manifest.js";
 import { diffSidePath } from "./git-paths.js";
 import { classifyFailureOutput } from "./baseline.js";
 import { operationFactsAtHead, readOperationFacts } from "./operation-facts.js";
+import { isVitestTestCommand, manifestChildEnv, readTestReport, singleForkRetryCommand, toManifestPath } from "./test-manifest.js";
+import { TEST_REPORTER_SOURCE } from "./test-reporter.js";
 // Fable F4: acceptance judge shares review's 900s timeout — 300s default killed frontier judges on cap-sized diffs.
 const JUDGE_TIMEOUT_MS = 900_000;
 const CitationSchema = z.object({ path: z.string(), line: z.number().int() });
@@ -98,6 +102,26 @@ export function testFiltered(testCmd, name) {
     const fwd = wrapped ? "-- " : "";
     return `${testCmd} ${fwd}-t ${shq(pattern)}`;
 }
+// Queue row 179: the criterion's suite file as the runner's file argument AHEAD of the title filter, appended to a
+// base that already carries its forwarding separator (npmForwarded, under either runner). testFiltered keeps its
+// two-argument form: a criterion with no suite file, and the eval harness.
+const fileFiltered = (base, file, name) => `${base} ${shq(file)} -t ${shq(testFilterPattern(name))}`;
+// The forwarding separator, decided on shell WORDS — the test gate's tokenizer (test-manifest.ts shellTokens/words,
+// unexported) beside its unquoting — never on the raw text: behind any `NAME=value` assignments (whose value, even
+// ` -- `, is not a word of the command), an npm manager word, bare, quoted or escaped, gets ONE `--` unless a later
+// word already is `--` (bare, quoted or escaped). npx, pnpm, yarn and a direct runner forward their arguments as they
+// are. Both runners' branches append through it; the Vitest branch asks the gate's parser only whether the reporter
+// can be forwarded at all (V5), since that parser's own separator reads the raw text.
+const SHELL_TOKEN = /(?:[^\s'"\\&|;<>]+|'[^']*'|"(?:\\.|[^"\\])*"|\\.)+|[&|;<>]+/g;
+const unquoted = (token) => token.replace(/'([^']*)'|"((?:\\.|[^"\\])*)"|\\(.)/g, (_all, single, double, escaped) => single ?? (double !== undefined ? double.replace(/\\(["\\$`])/g, "$1") : escaped));
+function npmForwarded(testCmd) {
+    const raw = testCmd.match(SHELL_TOKEN) ?? [];
+    let manager = 0;
+    while (/^[A-Za-z_]\w*=/.test(raw[manager] ?? ""))
+        manager++;
+    const argv = raw.slice(manager).map(unquoted);
+    return argv[0] === "npm" && !argv.includes("--") ? `${testCmd} --` : testCmd;
+}
 const VitestListedTestsSchema = z.array(z.object({
     name: z.string(),
     file: z.string(),
@@ -238,6 +262,99 @@ function oracleExecutionFailure(label, code, stdout, stderr) {
         details: `oracle failed: ${label} (exit ${code})${tail(stderr || stdout)}`,
     };
 }
+// today's rule for a test oracle's run: exit 0 AND a positive printed run count (OBS-55: a zero-match run is vacuous).
+function countedTestRun(label, filter, r) {
+    if (r.code !== 0)
+        return oracleExecutionFailure(label, r.code, r.stdout, r.stderr);
+    const out = (r.stderr || "") + "\n" + (r.stdout || "");
+    const ran = testsRan(out);
+    if (ran === null || ran < 1) {
+        return { gate: "acceptance", pass: false,
+            details: `oracle failed: ${label} — name filter matched zero tests (filter: ${filter})${tail(out)}` };
+    }
+    return undefined;
+}
+/**
+ * Queue row 179 (D-2018, D-2019): a test criterion that declares its suite file L is satisfied by L alone — run
+ * 1248's oracles named one file and a same-titled test in another satisfied them. Closed table:
+ * L1 L absent or not a regular file (a directory included) in the worktree: a work verdict naming L, under either
+ *    runner, and the test command never starts.
+ * Vitest: L alone, file argument then title filter, under the test gate's nonce-bound per-file reporter, because
+ *    Vitest's file filter selects EVERY path containing L. PASS only when that report, of this nonce and ending in
+ *    its run-end certificate with exit 0, shows a passed body in module L and none run in any other module.
+ *    V2 L without the title (another file holding it): no passed body in L. V3 a deeper path ending with L holding
+ *    it, whether or not L does: a body run in another module. V4 report missing, another nonce or no certificate,
+ *    and V5 a script body the reporter cannot be forwarded to: fail closed, unverified.
+ * Other runner: L as its file argument before the title filter, today's run-count rule. Declared residual: such a
+ *    runner gives no per-file evidence, so a test of the title in a path containing L can still satisfy it there.
+ */
+async function landedTestOracle(testCmd, title, landing, worktree) {
+    const label = `test "${title}" in ${landing}`;
+    const passed = { gate: "acceptance", pass: true, details: `✓ test: ${title} (exit 0) in ${landing}` };
+    const work = (why) => ({ gate: "acceptance", pass: false, details: `oracle failed: ${label} — ${why}` });
+    const unverified = (why) => ({ gate: "acceptance", pass: false,
+        details: `oracle failed: ${label} — ${why}; unverified, failing closed`,
+        meta: { cause: "oracle-execution", classification: "infra", infra: true, retryable: false } });
+    const path = resolve(worktree, landing);
+    const within = relative(worktree, path);
+    let regular = false;
+    try {
+        regular = !within.startsWith("..") && !isAbsolute(within) && lstatSync(path).isFile();
+    }
+    catch { /* absent */ }
+    if (!regular)
+        return work(`suite file ${landing} is absent from the worktree or is not a regular file; the test command never started`);
+    if (!isVitestTestCommand(testCmd, worktree)) {
+        return countedTestRun(label, title, await sh(fileFiltered(npmForwarded(testCmd), landing, title), worktree)) ?? passed;
+    }
+    // V5: the test gate's own parser, through its one pure export, throws on a compound or non-direct script body,
+    // where an appended --reporter would reach some other command. Only its refusal is read: its separator reads the
+    // raw text, so a quoted `"--"` or an assignment's ` -- ` value would misplace the file, filter and reporter.
+    try {
+        singleForkRetryCommand(testCmd, worktree, [], []);
+    }
+    catch (error) {
+        return unverified(`the per-file reporter cannot be forwarded to this test command (${error instanceof Error ? error.message : String(error)})`);
+    }
+    const cmd = fileFiltered(npmForwarded(testCmd), landing, title);
+    const dir = mkdtempSync(join(tmpdir(), "tickmarkr-oracle-"));
+    try {
+        const nonce = randomBytes(16).toString("hex");
+        const reporterPath = join(dir, `test-reporter-${nonce}.mjs`);
+        const reportPath = join(dir, `test-report-${nonce}.json`);
+        writeFileSync(reporterPath, TEST_REPORTER_SOURCE);
+        const r = await shell(`${cmd} --reporter=${shq(reporterPath)} --outputFile=${shq(reportPath)}`, worktree, DEFAULT_SHELL_TIMEOUT_MS, false, { env: { ...manifestChildEnv(worktree), TICKMARKR_TEST_REPORT: reportPath, TICKMARKR_TEST_NONCE: nonce } });
+        const raw = readTestReport(reportPath);
+        const report = raw?.nonce === nonce ? raw : undefined;
+        if (r.code !== 0) {
+            // the reporter replaces the runner's own output: its failure identities are the evidence of a red.
+            const named = report ? [...Object.values(report.completed).flatMap((c) => c.failures ?? []), ...(report.certificate?.diagnostics ?? [])] : [];
+            return oracleExecutionFailure(label, r.code, r.stdout, [r.stderr, ...named].filter(Boolean).join("\n"));
+        }
+        if (!raw)
+            return unverified("the runner exited 0 but wrote no per-file report");
+        if (!report)
+            return unverified(`the per-file report carries nonce "${raw.nonce}", not this invocation's`);
+        if (report.certificate?.exitCode !== 0)
+            return unverified("the per-file report never reached its run-end certificate with exit 0");
+        const key = toManifestPath(within, worktree);
+        // a module completed more than once (one path in several projects) keeps only its LAST counters, so its record
+        // cannot show that no earlier completion ran a body: it counts as run.
+        const repeated = new Set(report.duplicateCompletions ?? []);
+        const elsewhere = [...new Set([...Object.keys(report.started), ...Object.keys(report.completed)])].filter((file) => {
+            const t = report.completed[file]?.tests;
+            return file !== key && (repeated.has(file) || !t || t.passed + t.failed > 0);
+        }).sort();
+        if (elsewhere.length)
+            return work(`the runner's per-file report shows a test body run outside ${landing}, in ${elsewhere.join(", ")} — only ${landing} can satisfy this criterion`);
+        if (!((report.completed[key]?.tests?.passed ?? 0) > 0))
+            return work(`the runner's per-file report shows no passing test of that title in ${landing}`);
+        return passed;
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
 // v1.70 / OBS-129: the new-file line numbers each changed HUNK spans, per path — parsed from the
 // unified-diff so a citation is validated against real changed regions, not a substring of the whole
 // diff text (which also matches the diff's own +++/@@ headers). A hunk's span is every new-file line it
@@ -355,17 +472,18 @@ judge, via, opts = {}) {
                 return { gate: "acceptance", pass: false,
                     details: `oracle failed: test "${a.test}" — no test command configured to run it (failing closed)` };
             }
-            const r = await sh(testFiltered(opts.testCmd, a.test), worktree);
-            const out = (r.stderr || "") + "\n" + (r.stdout || "");
-            if (r.code !== 0) {
-                return oracleExecutionFailure(`test "${a.test}"`, r.code, r.stdout, r.stderr);
+            // queue row 179: a declared suite file is the only file that can satisfy its criterion.
+            if (a.landing !== undefined) {
+                const landed = await landedTestOracle(opts.testCmd, a.test, a.landing, worktree);
+                if (!landed.pass)
+                    return landed;
+                passedDet.push(landed.details);
+                continue;
             }
             // OBS-55: exit 0 alone is vacuous when the name filter matched zero tests — fail closed.
-            const ran = testsRan(out);
-            if (ran === null || ran < 1) {
-                return { gate: "acceptance", pass: false,
-                    details: `oracle failed: test "${a.test}" — name filter matched zero tests (filter: ${a.test})${tail(out)}` };
-            }
+            const red = countedTestRun(`test "${a.test}"`, a.test, await sh(testFiltered(opts.testCmd, a.test), worktree));
+            if (red)
+                return red;
             passedDet.push(`✓ test: ${a.test} (exit 0)`);
         }
     }

package/dist/gates/llm.d.ts

@@ -1,7 +1,7 @@
 import { type WorkerAdapter } from "../adapters/types.js";
 import type { Effort } from "../graph/schema.js";
 import { type ExecutorDriver, type Slot } from "../drivers/types.js";
-import type { SeatLaunchCause } from "../drivers/orca.js";
+import { type SeatLaunchCause } from "../drivers/orca.js";
 export declare const GATE_PANE_SEP = " \u00B7 ";
 export declare const COMPLETION_FAKING_CHECKLIST = "## Completion-faking checklist\nHunt for these concrete completion-faking shortcuts before ruling on any criterion:\n- hardcoded-result: output or fixture hardcoded to satisfy the stated criterion instead of real logic\n- test-weakening: tests skipped, deleted, or assertions loosened until failing behavior looks green\n- vacuous-assertion: a test that cannot fail (asserts a constant, asserts its own setup, no assertion)\n- fixture-overfit: implementation narrowed to the exact test inputs rather than the described behavior\n- echo-not-implement: criterion text echoed in names, comments, or strings without the behavior itself\n- stub-left-behind: TODO, throw, or no-op stub where the real implementation should be\n- error-swallowing: catch or fallback that hides failures instead of handling them\n- self-mocking: the code under test mocked or faked so the test exercises the mock\n- check-bypass: lint, type, or CI checks disabled, relaxed, or excluded to get green\n- rename-as-work: code moved or renamed and presented as the requested change\n- scope-padding: unrelated edits padding the diff while the criterion's behavior is untouched\nWhen a criterion fails, the verdict MUST name which shortcut above it matches, or state that none does.";
 /** Fable F3: per-call nonce echoed in verdict JSON and gate exit markers. */

package/dist/gates/llm.js

@@ -1,11 +1,13 @@
 import { stripVTControlCharacters } from "node:util";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { constants } from "node:buffer";
 import { randomBytes } from "node:crypto";
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { matchesTrustDialog } from "../adapters/types.js";
+import { matchesTrustDialog, shq } from "../adapters/types.js";
 import { formatOwnedName, parseOwnedName } from "../drivers/types.js";
+import { CHECKOUT_MARK, checkoutProofLine } from "../drivers/orca.js";
 import { bannerShell, paneDispatchCommand, PLAIN_BANNER } from "../brand.js";
 import { sh } from "../run/git.js";
 import { harvestCpuFlatWindowMs, normalizeStallSnapshot, WorkerTreeCpuAccountant, } from "../run/stall.js";
@@ -204,6 +206,64 @@ const START_MARKER = "TICKMARKR_START_";
 const START_ROW = /^TICKMARKR_START_[\w-]+$/;
 const IDENTITY_LINE = /^(?:review\s*·|tickmarkr(?::|$))/;
 const IDENTITY_OPENERS = ["review ·", "tickmarkr"];
+// Row 135(a): the orca driver's launch preamble. create returns only once it read the complete checkout
+// frame, so every gate read holds the frame row whole — exactly checkoutProofLine's form (declared length
+// equal to half its lowercase hex, terminated) — or, as the last row, a strict prefix of that form.
+// Above it, as the first non-blank row, the shell may echo the typed launch line, which names that
+// frame's own checkout as `cd <shq checkout>`. Anything else shaped like them is the seat's. Frame rows
+// are read untrimmed: a trailing space or tab can never complete a frame or extend its prefix.
+function frameCheckout(row) {
+    const hex = /^TICKMARKR_CHECKOUT \d+:(.*);$/.exec(row)?.[1];
+    if (hex === undefined)
+        return undefined;
+    const checkout = Buffer.from(hex, "hex").toString("utf8");
+    return checkoutProofLine(checkout) === row ? checkout : undefined;
+}
+function partialFrameRow(row) {
+    if (row.length > 0 && `${CHECKOUT_MARK} `.startsWith(row))
+        return true;
+    const m = /^TICKMARKR_CHECKOUT (0|[1-9]\d*)(?::([0-9a-f]*))?$/.exec(row);
+    if (m === null || !printableFrameLength(m[1]))
+        return false;
+    return m[2] === undefined || frameHexCompletable(m[2], Number(m[1]));
+}
+// checkoutProofLine prints `TICKMARKR_CHECKOUT <n>:`, 2n hex digits and `;` as one string, so the length it
+// declares is a safe integer whose row fits the runtime's longest string. Any other length, unsafe or
+// non-finite included, is never its output, nor a prefix of one.
+function printableFrameLength(digits) {
+    const n = Number(digits);
+    return Number.isSafeInteger(n) && CHECKOUT_MARK.length + digits.length + 2 * n + 3 <= constants.MAX_STRING_LENGTH;
+}
+// A hex prefix checkoutProofLine could still extend to `bytes` bytes: valid UTF-8 so far, with its open
+// sequence closable inside the declared length. A trailing half byte is tried at each of its 16 values.
+function frameHexCompletable(hex, bytes) {
+    if (hex.length > bytes * 2)
+        return false;
+    const whole = Buffer.from(hex.slice(0, hex.length - (hex.length % 2)), "hex");
+    const candidates = hex.length % 2 === 0 ? [whole]
+        : Array.from({ length: 16 }, (_, lo) => Buffer.concat([whole, Buffer.of(parseInt(hex.at(-1), 16) * 16 + lo)]));
+    return candidates.some((c) => {
+        const owed = utf8Owed(c);
+        return owed !== undefined && owed <= bytes - c.length;
+    });
+}
+// Continuation bytes the last sequence still owes, or undefined when no continuation makes it UTF-8.
+function utf8Owed(bytes) {
+    try {
+        new TextDecoder("utf-8", { fatal: true }).decode(bytes, { stream: true });
+    }
+    catch {
+        return undefined;
+    }
+    let lead = bytes.length;
+    while (lead > 0 && bytes.length - lead < 3 && (bytes[lead - 1] & 0xc0) === 0x80)
+        lead--;
+    if (lead === 0)
+        return 0;
+    const b = bytes[lead - 1];
+    const size = b >= 0xf0 ? 4 : b >= 0xe0 ? 3 : b >= 0xc0 ? 2 : 1;
+    return Math.max(0, size - (bytes.length - lead + 1));
+}
 // 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.
@@ -215,6 +275,7 @@ function seatStart(output, adapterBannerRows) {
     let bannerAt; // next banner row expected once the banner has begun
     let adapterBannerAt;
     let identitySeen = false;
+    let frameSeen = false;
     let offset = 0;
     for (let i = 0; i < rows.length; i++) {
         const row = rows[i].replace(/[ \t]+$/, "");
@@ -222,8 +283,15 @@ function seatStart(output, adapterBannerRows) {
         const last = i === rows.length - 1;
         // Complete harness rows: equality against the shape the preamble allows at this stage.
         let accepted = false;
+        const below = last ? undefined : frameCheckout(rows[i + 1]);
         if (!identitySeen && stage < SEAT && t.length === 0)
             accepted = true; // blank rows between preamble rows
+        else if (stage === ECHO && !frameSeen && frameCheckout(rows[i]) !== undefined) {
+            frameSeen = true;
+            accepted = true;
+        }
+        else if (below !== undefined && row.includes(`cd ${shq(below)}`) && rows.slice(0, i).every((r) => r.trim() === ""))
+            accepted = true; // orca launch echo
         else if (stage <= ECHO && completeEchoRow(row))
             accepted = true;
         else if (stage <= START && START_ROW.test(row)) {
@@ -239,13 +307,10 @@ function seatStart(output, adapterBannerRows) {
             bannerAt++;
             accepted = true;
         }
-        else if (stage <= IDENTITY && adapterBannerAt === undefined && adapterBannerRows.includes(row)) {
+        else if (stage <= IDENTITY && adapterBannerRows.indexOf(row, adapterBannerAt ?? 0) >= 0) {
+            // A closed list in render order: each row at most once, in list order, skipping allowed.
             stage = BANNER;
-            adapterBannerAt = adapterBannerRows.indexOf(row) + 1;
-            accepted = true;
-        }
-        else if (stage <= IDENTITY && adapterBannerAt !== undefined && row === adapterBannerRows[adapterBannerAt]) {
-            adapterBannerAt++;
+            adapterBannerAt = adapterBannerRows.indexOf(row, adapterBannerAt ?? 0) + 1;
             accepted = true;
         }
         else if (!identitySeen && stage <= IDENTITY && IDENTITY_LINE.test(t)) {
@@ -262,21 +327,20 @@ function seatStart(output, adapterBannerRows) {
         // 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 === ECHO && !frameSeen && partialFrameRow(rows[i]))
+            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;
-        if (stage <= IDENTITY && (adapterBannerAt === undefined
-            ? adapterBannerRows.some((b) => b.startsWith(row))
-            : adapterBannerRows[adapterBannerAt]?.startsWith(row) === true))
+        if (stage <= IDENTITY && adapterBannerRows.slice(adapterBannerAt ?? 0).some((b) => b.startsWith(row)))
             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 (!identitySeen && stage <= IDENTITY
-            && (bannerAt === BANNER_ROWS.length
-                || (adapterBannerRows.length > 0 && adapterBannerAt === adapterBannerRows.length))
+            && (bannerAt === BANNER_ROWS.length || adapterBannerAt !== undefined)
             && IDENTITY_OPENERS.some((o) => o.startsWith(t)))
             return -1;
         return offset;
@@ -430,15 +494,20 @@ async function runViaDriverDetailed(adapter, model, prompt, cwd, via, timeoutMs
                 // OBS-1177: the beat is armed for an INTERACTIVE (pane) driver only. On the subprocess driver
                 // a headless `claude -p` buffers every byte until it exits, so 0 seat bytes at 30 s is not a
                 // dead launch; that seat keeps its full ceiling, which still bounds it (fail-closed by timeout).
-                if (reviewing && via.driver.interactive && !firstLivenessObserved && now - startedAt >= REVIEW_FIRST_LIVENESS_MS) {
+                // Queue row 184: an adapter whose pane review command buffers its whole output until exit
+                // (claude-code's `claude -p`) has written nothing of its own until its verdict, working or
+                // dead, so the beat cannot tell the two apart and does not arm for it; its ceiling bounds it.
+                if (reviewing && via.driver.interactive && adapter.paneReviewBuffersOutput !== true && !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.
+                    // OBS-944: 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. Until 2.8.3 the orca checkout frame
+                    // counted as seat bytes and kept every claude pane seat past this beat; once it stopped
+                    // counting (row 135(a)) the beat killed working claude reviewers too, hence the declared
+                    // exemption above (row 184), which restores that pre-2.8.3 bound for buffering adapters only.
+                    // 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "2.8.2",
+  "version": "2.8.4",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",