tickmarkr 2.1.9 → 2.2.1

package/dist/compile/collateral.js

@@ -262,6 +262,148 @@ export function criterionReadsOnly(text, target) {
     });
 }
 const ARCH_PAGES = ["docs/codebase/ARCHITECTURE.md", "docs/codebase/STRUCTURE.md"];
+// files[] is deliberately small, but a brace range can still be broad. If a pattern exceeds
+// this advisory budget, fail open instead of printing an unexpanded brace fragment as a directory.
+const MAX_BRACE_EXPANSIONS = 256;
+const RANGE_CHAR_START = 32;
+const RANGE_CHAR_END = 126;
+function isEscaped(input, index) {
+    let backslashes = 0;
+    for (let i = index - 1; i >= 0 && input[i] === "\\"; i--)
+        backslashes++;
+    return backslashes % 2 === 1;
+}
+function unescapeGlobLiteral(input) {
+    return input.replace(/\\(.)/g, "$1");
+}
+function rangeParts(body) {
+    const parts = [];
+    let depth = 0;
+    let start = 0;
+    let sawRange = false;
+    for (let i = 0; i < body.length - 1; i++) {
+        if (isEscaped(body, i))
+            continue;
+        const ch = body[i];
+        if (ch === "{") {
+            depth++;
+            continue;
+        }
+        if (ch === "}") {
+            depth = Math.max(0, depth - 1);
+            continue;
+        }
+        if (ch !== "." || body[i + 1] !== "." || isEscaped(body, i + 1) || depth !== 0)
+            continue;
+        parts.push(body.slice(start, i));
+        i++;
+        start = i + 1;
+        sawRange = true;
+    }
+    if (!sawRange)
+        return undefined;
+    parts.push(body.slice(start));
+    return parts;
+}
+function rangeAlternatives(body) {
+    const parts = rangeParts(body);
+    if (!parts)
+        return undefined;
+    const source = `[${parts.map(unescapeGlobLiteral).sort().join("-")}]`;
+    let re;
+    try {
+        re = new RegExp(`^${source}$`);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (let code = RANGE_CHAR_START; code <= RANGE_CHAR_END; code++) {
+        const ch = String.fromCharCode(code);
+        if (re.test(ch))
+            out.push(ch);
+        if (out.length > MAX_BRACE_EXPANSIONS)
+            return [];
+    }
+    return out;
+}
+function braceAlternatives(body) {
+    const alternatives = [];
+    let depth = 0;
+    let start = 0;
+    let hasComma = false;
+    for (let i = 0; i < body.length; i++) {
+        if (isEscaped(body, i))
+            continue;
+        const ch = body[i];
+        if (ch === "{") {
+            depth++;
+            continue;
+        }
+        if (ch === "}") {
+            depth = Math.max(0, depth - 1);
+            continue;
+        }
+        if (ch !== "," || depth !== 0)
+            continue;
+        alternatives.push(body.slice(start, i));
+        start = i + 1;
+        hasComma = true;
+    }
+    if (hasComma) {
+        alternatives.push(body.slice(start));
+        return alternatives;
+    }
+    return rangeAlternatives(body);
+}
+function expandableBrace(pattern) {
+    const opens = [];
+    let unsupported;
+    for (let i = 0; i < pattern.length; i++) {
+        if (isEscaped(pattern, i))
+            continue;
+        if (pattern[i] === "{") {
+            opens.push(i);
+            continue;
+        }
+        if (pattern[i] !== "}" || !opens.length)
+            continue;
+        const start = opens.pop();
+        const alternatives = braceAlternatives(pattern.slice(start + 1, i));
+        if (alternatives === undefined)
+            continue;
+        if (alternatives.length === 0) {
+            unsupported ??= { start, end: i, alternatives };
+            continue;
+        }
+        return { start, end: i, alternatives };
+    }
+    return unsupported;
+}
+function expandFilesPattern(pattern) {
+    const pending = [pattern];
+    const expanded = new Set();
+    let visited = 0;
+    while (pending.length) {
+        const candidate = pending.pop();
+        if (++visited > MAX_BRACE_EXPANSIONS)
+            return [];
+        const brace = expandableBrace(candidate);
+        if (!brace) {
+            expanded.add(unescapeGlobLiteral(candidate));
+            continue;
+        }
+        if (brace.alternatives.length === 0)
+            continue;
+        if (pending.length + brace.alternatives.length > MAX_BRACE_EXPANSIONS)
+            return [];
+        for (const alternative of brace.alternatives) {
+            pending.push(candidate.slice(0, brace.start) + alternative + candidate.slice(brace.end + 1));
+        }
+    }
+    const scoped = filesGlob(pattern);
+    return [...expanded].filter((candidate) => scoped(candidate));
+}
 function topLevelSrcDir(file) {
     const parts = file.replace(/^\.\//, "").replace(/\/+$/, "").split("/");
     if (parts[0] !== "src" || parts.length < 2 || !parts[1])
@@ -293,10 +435,13 @@ export function newDirectoryLints(tasks, repoRoot) {
         const scoped = filesGlob(t.files.map((f) => f.replace(/^\.\//, "")));
         const newDirs = new Set();
         for (const f of t.files) {
-            const dir = topLevelSrcDir(f);
-            if (!dir || existing.has(dir))
-                continue;
-            newDirs.add(`src/${dir}/`);
+            const normalized = f.replace(/^\.\//, "");
+            for (const expanded of expandFilesPattern(normalized)) {
+                const dir = topLevelSrcDir(expanded);
+                if (!dir || existing.has(dir))
+                    continue;
+                newDirs.add(`src/${dir}/`);
+            }
         }
         if (!newDirs.size)
             continue;

package/dist/compile/native.js

@@ -724,6 +724,7 @@ acceptance is required on every task (a nested list of observable outcomes).
                  - command: <shell>   (oracle: command — exit code)
                  - test: <name>       (oracle: test — named test)
                  - judge: <rubric>    (oracle: judge — LLM-judged, free text)
+                 A judge criterion carries ONE claim; a semicolon-joined criterion warns — split its clauses.
                  - <plain text>       (compat: compiles as judge oracle, warns)
 
   HARD BOUNDS — these FAIL the compile, they do not warn:
@@ -839,6 +840,7 @@ acceptance is required on every task (a nested list of observable outcomes).
   ORDERING AND OWNERSHIP:
     - Every path has exactly ONE owning task. Two tasks writing one file must be ORDERED by deps, or the
       loser's work is silently dropped when the integration tip advances.
+    - A task changing what the daemon DOES must own every surface that TELLS the operator what the daemon does.
     - A file one task CREATES cannot be "context:" for another — only deps: carries it, and that extends to
       the task that PRODUCES a value, not just the file's existence.
     - Deleting or renaming a symbol is a cross-task contract. Sweep for consumers by symbol AND by what the

package/dist/drivers/index.d.ts

@@ -4,4 +4,5 @@ export declare const DRIVER_CHOICES: readonly ["auto", "herdr", "subprocess", "o
 export type DriverChoice = (typeof DRIVER_CHOICES)[number];
 /** Validate argv at the CLI boundary rather than casting an arbitrary string into a driver choice. */
 export declare function parseDriverOverride(override?: string): DriverChoice | undefined;
+export declare function driverEvidence(cfg: TickmarkrConfig, driver: ExecutorDriver, override?: string): string;
 export declare function pickDriver(cfg: TickmarkrConfig, override?: string): ExecutorDriver;

package/dist/drivers/index.js

@@ -2,6 +2,7 @@ import { HerdrDriver } from "./herdr.js";
 import { OrcaDriver } from "./orca.js";
 import { SubprocessDriver } from "./subprocess.js";
 export const DRIVER_CHOICES = ["auto", "herdr", "subprocess", "orca"];
+const overrideByDriver = new WeakMap();
 /** Validate argv at the CLI boundary rather than casting an arbitrary string into a driver choice. */
 export function parseDriverOverride(override) {
     if (override === undefined)
@@ -11,18 +12,32 @@ export function parseDriverOverride(override) {
             return choice;
     throw new Error(`usage: --driver must be one of ${DRIVER_CHOICES.join(" | ")} (got ${override})`);
 }
+export function driverEvidence(cfg, driver, override) {
+    const selectedOverride = override ?? overrideByDriver.get(driver);
+    const want = parseDriverOverride(selectedOverride) ?? cfg.driver;
+    if (selectedOverride !== undefined)
+        return `${driver.id} (--driver)`;
+    if (want !== "auto")
+        return `${driver.id} (config)`;
+    const herdrAvailable = process.env.HERDR_ENV === "1";
+    if (driver.id === (herdrAvailable ? "herdr" : "subprocess")) {
+        return `auto → ${driver.id} (${herdrAvailable ? "HERDR_ENV=1" : "HERDR_ENV unset"})`;
+    }
+    return `auto → ${driver.id} (runtime)`;
+}
 export function pickDriver(cfg, override) {
-    const want = parseDriverOverride(override) ?? cfg.driver;
+    const selectedOverride = parseDriverOverride(override);
+    const want = selectedOverride ?? cfg.driver;
     // VIS-09 item 2: plumb the per-tab cap into the HerdrDriver — the driver takes it as a constructor
     // param and never imports config (cfg is the only seam). Guaranteed present: DEFAULT_CONFIG seeds
     // workersPerTab:3 and deepMerge overlays on top, so a missing overlay key still resolves.
-    if (want === "herdr")
-        return new HerdrDriver("herdr", cfg.visibility.workersPerTab);
-    if (want === "subprocess")
-        return new SubprocessDriver();
-    // Orca is an operator-selected execution surface. Its runtime failure stays on Orca; selection
-    // must never substitute a hidden subprocess worker after this explicit choice.
-    if (want === "orca")
-        return new OrcaDriver();
-    return HerdrDriver.available() ? new HerdrDriver("herdr", cfg.visibility.workersPerTab) : new SubprocessDriver();
+    const driver = want === "herdr" ? new HerdrDriver("herdr", cfg.visibility.workersPerTab)
+        : want === "subprocess" ? new SubprocessDriver()
+            // Orca is an operator-selected execution surface. Its runtime failure stays on Orca; selection
+            // must never substitute a hidden subprocess worker after this explicit choice.
+            : want === "orca" ? new OrcaDriver()
+                : HerdrDriver.available() ? new HerdrDriver("herdr", cfg.visibility.workersPerTab) : new SubprocessDriver();
+    if (selectedOverride !== undefined)
+        overrideByDriver.set(driver, selectedOverride);
+    return driver;
 }

package/dist/drivers/orca.d.ts

@@ -3,7 +3,12 @@ import { type ExecutorDriver, type NotifyOpts, type Slot, type SlotOpts } from "
 /** The response families the ONE shared envelope parser serves. There is no second JSON seam. */
 export declare const ORCA_RESPONSE_FAMILIES: readonly ["status", "create", "list", "read", "send", "wait", "show", "close"];
 export type OrcaFamily = (typeof ORCA_RESPONSE_FAMILIES)[number];
+export declare const ORCA_FIXTURE_VERSION = "1.4.195";
+export declare const ORCA_CLI_COMMAND_ENV = "ORCA_CLI_COMMAND";
 export declare const STALE_HANDLE_CODE = "terminal_handle_stale";
+export declare const TERMINAL_GONE_CODE = "terminal_gone";
+export declare const STALE_HANDLE_CODES: Set<string>;
+export declare const WAIT_TIMEOUT_CODE = "timeout";
 export declare const NOT_WRITABLE_CODE = "terminal_not_writable";
 /** The ONLY terminal status that licenses reading a terminal's bytes or its agent state. */
 export declare const RUNNING_STATUS = "running";
@@ -38,6 +43,18 @@ export interface OrcaEnvelope {
     runtimeId: string;
     raw: string;
 }
+export interface OrcaBinaryResolverOpts {
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+    platform?: NodeJS.Platform;
+    resolve?: (bin: string, cwd: string) => {
+        resolved?: string;
+    };
+}
+/**
+ * One Orca CLI name decision for both the driver and doctor. Linux desktop systems can have
+ * GNOME's screen-reader `orca` on PATH, so outside an Orca terminal the app CLI is `orca-ide`.
+ */
+export declare function resolveOrcaCliBinary(cwd?: string, opts?: OrcaBinaryResolverOpts): string | undefined;
 /**
  * The one JSON seam. Fails CLOSED on every degenerate response — empty, unparseable (a truncated
  * body lands here), non-object, no boolean `ok`, `ok:false`, `ok:true` with no result object, or a
@@ -76,6 +93,8 @@ export declare function mapAgentState(term: Record<string, unknown>, tuiIdle: bo
 export declare function joinWrapped(raw: string): string;
 export interface OrcaDriverOpts {
     bin?: string;
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+    platform?: NodeJS.Platform;
     exec?: OrcaExec;
     time?: OrcaTimeSource;
     pageLines?: number;

package/dist/drivers/orca.js

@@ -8,7 +8,7 @@ import { formatOwnedName, panesToClose } from "./types.js";
 // worktrees, routing, gates, journal and merges; orca supplies visible terminals only. Everything
 // here is bound by the 1.4.186 conformance spike
 // (.planning/assessments/2026-08-21-orca-driver-conformance.md, CONFORMANCE-END) and the
-// recorded refusal transport (process rc 1 + ok:false on stdout):
+// 1.4.195 drift capture (.planning/assessments/2026-09-02-orca-1.4.195-capture/):
 //
 //  - reads arrive as `result.terminal.tail` line arrays with line-indexed cursors and a `status`
 //    field on the same object (C2); a CLOSED terminal answers ok:true with its own dead record
@@ -32,7 +32,12 @@ import { formatOwnedName, panesToClose } from "./types.js";
 //    an older run's leftover sits in a checkout this run never knew (T2).
 /** The response families the ONE shared envelope parser serves. There is no second JSON seam. */
 export const ORCA_RESPONSE_FAMILIES = ["status", "create", "list", "read", "send", "wait", "show", "close"];
+export const ORCA_FIXTURE_VERSION = "1.4.195";
+export const ORCA_CLI_COMMAND_ENV = "ORCA_CLI_COMMAND";
 export const STALE_HANDLE_CODE = "terminal_handle_stale";
+export const TERMINAL_GONE_CODE = "terminal_gone";
+export const STALE_HANDLE_CODES = new Set([STALE_HANDLE_CODE, TERMINAL_GONE_CODE]);
+export const WAIT_TIMEOUT_CODE = "timeout";
 export const NOT_WRITABLE_CODE = "terminal_not_writable";
 /** The ONLY terminal status that licenses reading a terminal's bytes or its agent state. */
 export const RUNNING_STATUS = "running";
@@ -79,6 +84,19 @@ export class OrcaUnavailableError extends OrcaError {
 function str(v) {
     return typeof v === "string" && v ? v : undefined;
 }
+/**
+ * One Orca CLI name decision for both the driver and doctor. Linux desktop systems can have
+ * GNOME's screen-reader `orca` on PATH, so outside an Orca terminal the app CLI is `orca-ide`.
+ */
+export function resolveOrcaCliBinary(cwd = process.cwd(), opts = {}) {
+    const env = opts.env ?? process.env;
+    const explicit = env[ORCA_CLI_COMMAND_ENV]?.trim();
+    if (explicit)
+        return explicit;
+    const platform = opts.platform ?? process.platform;
+    const selected = platform === "linux" && env.TERM_PROGRAM !== "Orca" ? "orca-ide" : "orca";
+    return opts.resolve ? opts.resolve(selected, cwd).resolved : selected;
+}
 /**
  * The one JSON seam. Fails CLOSED on every degenerate response — empty, unparseable (a truncated
  * body lands here), non-object, no boolean `ok`, `ok:false`, `ok:true` with no result object, or a
@@ -235,7 +253,7 @@ export class OrcaDriver {
     pollMs;
     probeStalenessMs;
     constructor(opts = {}) {
-        this.bin = opts.bin ?? "orca";
+        this.bin = opts.bin ?? resolveOrcaCliBinary(process.cwd(), { env: opts.env, platform: opts.platform }) ?? "orca";
         // Config values flow into a shell here: every argv element is quoted, always.
         this.exec = opts.exec ?? ((args, cwd, timeoutMs) => {
             return sh([this.bin, ...args].map(shq).join(" "), cwd, timeoutMs);
@@ -257,14 +275,13 @@ export class OrcaDriver {
         // diagnostic is never discarded before the one shared parser reports it.
         const raw = [r.stdout, r.stderr ? `STDERR: ${r.stderr}` : ""].filter(Boolean).join("\n");
         if (r.code !== 0) {
-            // Recorded 1.4.186 refusal transport: the process exits rc 1 with the STRUCTURED ok:false
+            // Recorded refusal transport: the process exits rc 1 with the STRUCTURED ok:false
             // body on stdout. Parse it so the refusal CODE survives (terminal_handle_stale,
             // terminal_not_writable) — everything downstream that recovers on a code depends on this
-            // branch. The one documented exception is an elapsed `terminal wait`: it exits 1 but carries
-            // an ok:true, `wait.satisfied:false` receipt. It remains the shared parser's success path;
-            // waitCondition() validates its identity, handle, condition and running status before it
-            // becomes the normal `false` result. Any other ok:true body on a nonzero exit stays a
-            // transport failure (a shell/runtime crash can leave stale stdout behind).
+            // branch. Elapsed `terminal wait` has two recorded transports: 1.4.186's ok:true,
+            // `wait.satisfied:false` receipt and 1.4.195's ok:false/code:timeout refusal. Each remains
+            // scoped to wait only; any other ok:true body on a nonzero exit stays a transport failure (a
+            // shell/runtime crash can leave stale stdout behind).
             try {
                 const env = parseEnvelope(family, r.stdout, raw);
                 const wait = env.result.wait;
@@ -279,6 +296,21 @@ export class OrcaDriver {
                 }
             }
             catch (e) {
+                if (family === "wait"
+                    && r.code === 1
+                    && !r.timedOut
+                    && e instanceof OrcaError
+                    && e.code === WAIT_TIMEOUT_CODE
+                    && e.runtimeId
+                    && e.runtimeId !== "none") {
+                    const handle = args[args.indexOf("--terminal") + 1];
+                    const condition = args[args.indexOf("--for") + 1];
+                    return {
+                        result: { wait: { handle, condition, satisfied: false, status: RUNNING_STATUS } },
+                        runtimeId: e.runtimeId,
+                        raw,
+                    };
+                }
                 // The refusal code lives in stdout alone, but the raw bytes propagated to the caller must
                 // still be the COMBINED stream — stderr can carry the diagnostic that explains the refusal.
                 if (e instanceof OrcaError && !(e instanceof OrcaUnavailableError) && e.code !== undefined) {
@@ -392,6 +424,10 @@ export class OrcaDriver {
         st.handle = handle;
         // The handle is bound to the runtime identity that ANSWERED its create.
         st.runtimeId = env.runtimeId;
+        const surface = str(term.surface);
+        if (surface !== undefined && surface !== "visible") {
+            await this.notify(`tickmarkr orca terminal created on ${surface} surface`, { tier: "attention" });
+        }
     }
     // ---- handle identity and restart recovery ----------------------------------------------------
     /**
@@ -450,7 +486,7 @@ export class OrcaDriver {
                             await relist(e.runtimeId, e.raw);
                             continue;
                         }
-                        if (e.code === STALE_HANDLE_CODE) {
+                        if (STALE_HANDLE_CODES.has(e.code)) {
                             await relist(e.runtimeId, e.raw);
                             continue;
                         }

package/dist/gates/baseline.d.ts

@@ -45,6 +45,8 @@ export interface BaselineCommand {
      * verdict: no exit code, no fingerprints, nothing forgivable.
      */
     infra?: true;
+    /** Runner-level exhaustion lines that invalidated a completed capture. */
+    invalidatingLines?: string[];
 }
 export interface BaselineFileDuration {
     file: string;

package/dist/gates/baseline.js

@@ -85,7 +85,7 @@ const TURBO_FAIL_RE = /^\s*(?:[\w@./-]+:\s*)*ELIFECYCLE\s+Command failed\b|^\s*F
 // at least TWO colon-joined segments (`<pkg>:<task>:`, tasks may nest — `pkg:test:unit:`), every
 // segment after the first starting with a letter — so `Error: boom` (one segment), `src/x.ts:12:`
 // (digit segment) and `12:34 error` (eslint stylish) are never stripped.
-const TURBO_PREFIX_RE = /^\s*[\w@./-]+(?::[A-Za-z_][\w.-]*)+:\s+/;
+const TURBO_PREFIX_RE = /^\s*[\w@./-]+(?::[A-Za-z_][\w.-]*)+:(?:\s+|$)/;
 const stripTurboPrefix = (l) => {
     const m = TURBO_PREFIX_RE.exec(l);
     return m ? l.slice(m[0].length) : undefined;
@@ -161,11 +161,36 @@ export function classifyFailureOutput(output) {
  * no failure in that incomplete environment can safely become pre-existing forgiveness. Keep this
  * separate from `classifyFailureOutput` so changing capture policy cannot move gate verdicts.
  */
-const captureHasInvalidatingInfra = (output) => output
-    .split("\n")
-    .map((l) => l.replace(ANSI_RE, ""))
-    .filter((l) => !PASS_LINE_RE.test(l))
-    .some((l) => CAPTURE_EXHAUSTION_RE.test(l));
+const VITEST_ECHO_BLOCK_RE = /^\s*std(?:out|err)\s+\|\s+\S+\.(?:test|spec)\.[cm]?[jt]sx?\s+>\s+\S/;
+/** Keep runner output while omitting Vitest's echoed test-owned stdout/stderr diagnostic blocks. */
+const withoutVitestEchoBlocks = (output) => {
+    const outside = [];
+    let inVitestEchoBlock = false;
+    for (const line of output.split("\n")) {
+        const clean = line.replace(ANSI_RE, "");
+        const runnerLine = stripTurboPrefix(clean) ?? clean;
+        if (inVitestEchoBlock) {
+            if (runnerLine.trim() === "")
+                inVitestEchoBlock = false;
+            continue;
+        }
+        if (VITEST_ECHO_BLOCK_RE.test(runnerLine)) {
+            inVitestEchoBlock = true;
+            continue;
+        }
+        outside.push(line);
+    }
+    return outside;
+};
+const captureInvalidatingLines = (output) => {
+    const invalidating = [];
+    for (const line of withoutVitestEchoBlocks(output)) {
+        const clean = line.replace(ANSI_RE, "");
+        if (!PASS_LINE_RE.test(clean) && CAPTURE_EXHAUSTION_RE.test(clean))
+            invalidating.push(line);
+    }
+    return invalidating;
+};
 const normalizeLine = (l) => l.replace(/\d+/g, "#").replace(/\s+/g, " ").trim();
 // Vitest's default reporter names file durations as
 // `✓ |project| tests/example.test.ts (12 tests) 1.23s` (❯ for a red file). The runner may be
@@ -203,8 +228,7 @@ export const UNRECOGNIZED_FAILURE = "<unrecognized failure output>";
 // renders "zone +3 · run attempt 2 · 1 failed" (what T9 is chartered to draw) contributes nothing, with
 // or without box glyphs, so it cannot manufacture a fresh-fingerprint rejection on any future attempt.
 export function fingerprint(output) {
-    const lines = output
-        .split("\n")
+    const lines = withoutVitestEchoBlocks(output)
         .map((l) => l.replace(ANSI_RE, ""))
         .filter((l) => !PASS_LINE_RE.test(l));
     // GATE-FIX-4 DEFECT 4: every line is read twice — as printed, and with a turbo `<pkg>:<task>:`
@@ -403,7 +427,7 @@ export function ceilingKillResult(gate, r, ceilingMs) {
  * shell asks it to finish faster than the thing it is measuring.
  */
 export const CAPTURE_CEILING_MS = 1_800_000;
-const invalidCaptureEntry = (durationMs) => ({
+const invalidCaptureEntry = (durationMs, invalidatingLines = []) => ({
     infra: true,
     fingerprints: [],
     durationMs,
@@ -411,6 +435,7 @@ const invalidCaptureEntry = (durationMs) => ({
     impliedParallelism: null,
     longestFile: null,
     ceilingMs: effectiveCeilingMs({ durationMs }),
+    ...(invalidatingLines.length ? { invalidatingLines } : {}),
 });
 export async function captureBaseline(cwd, commands) {
     const base = { commands: {} };
@@ -441,17 +466,20 @@ export async function captureBaseline(cwd, commands) {
             base.commands[name] = invalidCaptureEntry(durationMs);
             continue;
         }
-        const raw = (r.stdout + "\n" + r.stderr).split(cwd).join("");
+        const combinedOutput = r.stdout + "\n" + r.stderr;
+        const raw = combinedOutput.split(cwd).join("");
         // Run 2137: the child exited and printed ordinary FAIL/AssertionError lines, so the gate-side
         // discriminator correctly called the mixed output a regression. But the same output also said
         // `spawn EAGAIN`: the machine had run out of processes while the pristine-tree measurement was
         // being taken. A capture cannot know which red lines predated that shortage and which it caused,
         // so none may become a fingerprint every later task gets to forgive.
-        if (captureHasInvalidatingInfra(raw)) {
+        const invalidatingLines = captureInvalidatingLines(combinedOutput);
+        if (invalidatingLines.length) {
             console.error(`tickmarkr: baseline capture for "${name}" completed with process/resource-exhaustion evidence — `
                 + `it recorded NO exit-code verdict and NO fingerprints, so nothing is forgiven for this command; `
-                + `the measurement cannot distinguish a pre-existing failure from one caused by exhaustion.`);
-            base.commands[name] = invalidCaptureEntry(durationMs);
+                + `the measurement cannot distinguish a pre-existing failure from one caused by exhaustion. `
+                + `First invalidating line: ${invalidatingLines[0]}`);
+            base.commands[name] = invalidCaptureEntry(durationMs, invalidatingLines);
             continue;
         }
         base.commands[name] = {
@@ -530,7 +558,14 @@ export async function compareToBaseline(cwd, commands, baseline, enabled) {
         if (!cmd) {
             // nothing detected for this gate in the target repo — journal an explicit skip instead of
             // vanishing silently (a lint gate with no lint script rendered as forever-open in status)
-            results.push({ gate: name, pass: true, details: `no ${name} command detected — skipped`, meta: { skipped: true } });
+            const reason = `no ${name} command detected`;
+            const outcome = { kind: "skipped", reason };
+            results.push({
+                gate: name,
+                pass: true,
+                details: `${reason} — skipped`,
+                meta: { skipped: true, outcome },
+            });
             continue;
         }
         const entry = baseline.commands[name];

package/dist/gates/llm.d.ts

@@ -1,4 +1,4 @@
-import type { WorkerAdapter } from "../adapters/types.js";
+import { type WorkerAdapter } from "../adapters/types.js";
 import { type ExecutorDriver, type Slot } from "../drivers/types.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.";

package/dist/gates/llm.js

@@ -3,6 +3,7 @@ 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 { formatOwnedName, parseOwnedName } from "../drivers/types.js";
 import { bannerShell, paneDispatchCommand } from "../brand.js";
 import { sh } from "../run/git.js";
@@ -161,6 +162,16 @@ export async function runViaDriver(adapter, model, prompt, cwd, via, timeoutMs =
         slot = await via.driver.slot(cwd, rolePaneNameFromPrompt(prompt, via.name), via.label ? { label: via.label } : undefined);
         via.onSlot?.(slot);
         await via.driver.run(slot, paneDispatchCommand(scriptPath));
+        if (via.driver.sendKey) {
+            try {
+                if (matchesTrustDialog(await via.driver.read(slot, 400), adapter.trustDialog)) {
+                    await via.driver.sendKey(slot, adapter.trustDialog.key);
+                }
+            }
+            catch {
+                /* a failed pre-wait read must not replace the verdict wait */
+            }
+        }
         // nonce-suffixed exit only: a displayed bare "TICKMARKR_EXIT:" or another call's marker must not
         // false-complete — same guard the worker path uses (daemon.ts:330-331).
         const exitPattern = `TICKMARKR_EXIT_${nonce}:\\d`;
@@ -369,37 +380,41 @@ export function extractVerdictJson(raw, nonce) {
             /* fall through */
         }
     }
-    let pos = raw.length - 1;
-    while (pos >= 0) {
-        const end = raw.lastIndexOf("}", pos);
-        if (end === -1)
-            return null;
-        let depth = 1;
-        let stepped = false;
-        for (let i = end - 1; i >= 0; i--) {
-            if (raw[i] === "}")
+    for (let start = raw.lastIndexOf("{"); start >= 0;) {
+        const nextStart = start === 0 ? -1 : raw.lastIndexOf("{", start - 1);
+        let depth = 0;
+        let quoted = false;
+        let escaped = false;
+        for (let i = start; i < raw.length; i++) {
+            const char = raw[i];
+            if (quoted) {
+                if (escaped)
+                    escaped = false;
+                else if (char === "\\")
+                    escaped = true;
+                else if (char === '"')
+                    quoted = false;
+                continue;
+            }
+            if (char === '"')
+                quoted = true;
+            else if (char === "{")
                 depth++;
-            else if (raw[i] === "{") {
-                depth--;
-                if (depth === 0) {
-                    stepped = true;
-                    try {
-                        const v = JSON.parse(raw.slice(i, end + 1));
-                        if (v && typeof v === "object" && v.nonce === nonce) {
-                            const { nonce: _n, ...rest } = v;
-                            return rest;
-                        }
-                    }
-                    catch {
-                        /* keep scanning */
+            else if (char === "}" && --depth === 0) {
+                try {
+                    const v = JSON.parse(raw.slice(start, i + 1));
+                    if (v && typeof v === "object" && v.nonce === nonce) {
+                        const { nonce: _n, ...rest } = v;
+                        return rest;
                     }
-                    pos = i - 1;
-                    break;
                 }
+                catch {
+                    /* keep scanning */
+                }
+                break;
             }
         }
-        if (!stepped)
-            return null;
+        start = nextStart;
     }
     return null;
 }

package/dist/gates/review.js

@@ -348,6 +348,7 @@ The top-level comments array is optional. Use it only for actionable line-anchor
         // OBS-196: name the cause and persist the raw bytes — a ruled-on "unparseable" without its
         // evidence cannot be audited, and a cutoff must never be indistinguishable from a parse defect.
         const cause = classifyVerdictCause(raw, nonce, "approve");
+        const bytes = Buffer.byteLength(raw, "utf8");
         let saved;
         if (artifactDir) {
             try {
@@ -372,6 +373,7 @@ The top-level comments array is optional. Use it only for actionable line-anchor
                 reviewer: channelKey(reviewer),
                 unparseable: true,
                 cause,
+                ...(cause === "empty-output" ? { bytes } : {}),
                 ...(concludedOnInactivity ? { classification: "infra", infra: true } : {}),
             },
         };

package/dist/gates/run-gates.d.ts

@@ -31,6 +31,12 @@ export type GateEvent = {
     phase: "end";
     gate: GateName;
     result: GateResult;
+} | {
+    phase: "note";
+    gate: GateName;
+    name: string;
+    payload: Record<string, unknown>;
+    result: GateResult;
 };
 export interface GateContext {
     worktree: string;