tickmarkr 2.2.0 → 2.2.1

package/dist/adapters/model-lints.js

@@ -3,6 +3,7 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { DEFAULT_CONFIG, TIER_RANK } from "../config/config.js";
 import { filesGlob } from "../graph/files-glob.js";
+import { piModelVendor } from "./pi.js";
 import { buildTaskPrompt } from "./prompt.js";
 import { channelKey, MODEL_ID_RE } from "./types.js";
 import { resolveCatalogModel } from "./catalog-remote.js";
@@ -446,6 +447,14 @@ export function modelLints(cfg, health, adapters, opts) {
     const lints = [];
     for (const adapter of adapters) {
         const id = adapter.id;
+        if (id === "pi" && adapter.channels) {
+            for (const channel of adapter.channels(cfg)) {
+                const expected = cfg.tiers.pi?.modelOverrides?.[channel.model]?.vendor ?? piModelVendor(channel.model);
+                if (expected && channel.vendor !== expected) {
+                    lints.push(`pi: ${channel.model} channel vendor ${channel.vendor} disagrees with provider vendor ${expected} — set tiers.pi.modelOverrides.${channel.model}.vendor to ${expected}`);
+                }
+            }
+        }
         if (!adapter.listModels) {
             // v1.90 / OBS-504: the seeds-stamped wording presumes a seeded tier table. agy ships routable
             // but UNCLASSIFIED (no listModels, no seed models) — for that shape the honest sentence names

package/dist/adapters/pi.d.ts

@@ -6,4 +6,5 @@ export interface ServedModelDrift {
 }
 export declare function readPiServedModels(): ServedModelDrift[];
 export declare function servedModelNote(drifts?: ServedModelDrift[]): string;
+export declare function piModelVendor(model: string): string | undefined;
 export declare const pi: WorkerAdapter;

package/dist/adapters/pi.js

@@ -118,6 +118,17 @@ export function servedModelNote(drifts = readPiServedModels()) {
         return "";
     return `served-model drift: ${drifts.map((d) => `pinned ${d.pinned} served ${d.served}`).join(", ")}`;
 }
+const PI_PROVIDER_VENDORS = {
+    anthropic: "anthropic",
+    google: "google",
+    openai: "openai",
+    "openai-codex": "openai",
+    xai: "xai",
+    zai: "zhipu",
+};
+export function piModelVendor(model) {
+    return PI_PROVIDER_VENDORS[model.split("/", 1)[0]];
+}
 export const pi = {
     id: "pi",
     // FLEET-04: cross-vendor review honesty — GLM's provider (pi's own label is "zai"; either is
@@ -140,7 +151,10 @@ export const pi = {
         const note = `auth verified via pi --list-models (free; auth-filtered by pi)${drift ? `; ${drift}` : ""}`;
         return { ...h, servable: parsePiModels(r.stdout || ""), note };
     },
-    channels: (cfg) => channelsFromConfig("pi", cfg),
+    channels: (cfg) => channelsFromConfig("pi", cfg).map((channel) => ({
+        ...channel,
+        vendor: cfg.tiers.pi?.modelOverrides?.[channel.model]?.vendor ?? piModelVendor(channel.model) ?? channel.vendor,
+    })),
     // v1.65 T3: every flag the command builders below hardcode — verified in `pi --help` 2026-07-22.
     hardcodedFlags: { binary: "pi", flags: ["-p", "--approve", "--model"] },
     // --approve: pi's per-directory trust prompt would stall fresh worktrees (herdr scrapes the dialog

package/dist/adapters/prompt.js

@@ -1,4 +1,4 @@
-import { mkdirSync, writeFileSync } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { renderAcceptanceItem } from "../graph/schema.js";
 import { classifyVerdictCause } from "../gates/verdict-cause.js";
@@ -30,8 +30,16 @@ TICKMARKR_RESULT_${nonce} {"ok":true|false,"summary":"<one sentence>","deviation
 `;
 }
 export function writePrompt(dir, task, attempt, feedback = "", nonce = "") {
-    const p = join(dir, "prompts", `${task.id}-a${attempt}.md`);
-    mkdirSync(join(dir, "prompts"), { recursive: true });
+    const prompts = join(dir, "prompts");
+    const p = join(prompts, `${task.id}-a${attempt}.md`);
+    mkdirSync(prompts, { recursive: true });
+    if (existsSync(p)) {
+        let engagement = 0;
+        let archive = join(prompts, `${task.id}-a${attempt}-engagement-${engagement}.md`);
+        while (existsSync(archive))
+            archive = join(prompts, `${task.id}-a${attempt}-engagement-${++engagement}.md`);
+        copyFileSync(p, archive);
+    }
     writeFileSync(p, buildTaskPrompt(task, feedback, nonce));
     return p;
 }

package/dist/adapters/registry.js

@@ -11,7 +11,7 @@ import { FakeAdapter } from "./fake.js";
 import { parseWorkerResult } from "./prompt.js";
 import { sealHerdrEnv } from "../drivers/subprocess.js";
 import { catalogEntries, isNativeCliDrive, projectCliEntries, SHIPPED_CLI_CATALOG, } from "./catalog.js";
-import { channelKey, channelsFromConfig, modelAuthed, MODEL_ID_RE, QUOTA_RE, shq, } from "./types.js";
+import { channelKey, channelsFromConfig, modelAuthed, MODEL_ID_RE, MODEL_PROBE_ERRORS, QUOTA_RE, shq, } from "./types.js";
 // Compatibility projection for callers/tests that only need shipped advisory names. The literal
 // list is gone: both advisory and routable catalog views derive from SHIPPED_CLI_CATALOG. Native
 // definitions (claudeCode, codex, cursorAgent, opencode, pi, grok, kimi) are owned by catalog.ts;
@@ -410,6 +410,12 @@ function probeFailure(code, stdout, stderr, timedOut, timeoutMs = MODEL_PROBE_TI
         ? reasonTail(output) || `probe exited ${code}`
         : undefined;
 }
+const PROBE_ERROR_RE = new RegExp(`\\b(${MODEL_PROBE_ERRORS.join("|")})\\b`);
+function probeError(code, stdout, stderr, timedOut) {
+    if (timedOut || code === 0)
+        return undefined;
+    return PROBE_ERROR_RE.exec(`${stderr}\n${stdout}`)?.[1];
+}
 const probeModelStatus = (v) => v.authed ? "ok" : v.reason?.includes("timed out") ? "timeout" : "failed";
 // v1.21: one bounded, headless call per configured model; detected-but-unclassified models never enter this loop.
 export async function probeModels(cfg, repoRoot, adapters, health, onProgress) {
@@ -436,7 +442,7 @@ export async function probeModels(cfg, repoRoot, adapters, health, onProgress) {
             const attempt = async (model, retry) => {
                 const t0 = Date.now();
                 const probedAt = new Date().toISOString();
-                const v = (authed, reason) => ({ authed, ...(reason !== undefined ? { reason } : {}), probedAt, durationMs: Date.now() - t0 });
+                const v = (authed, reason, error) => ({ authed, ...(reason !== undefined ? { reason } : {}), ...(error ? { probeError: error } : {}), probedAt, durationMs: Date.now() - t0 });
                 try {
                     if (typeof a.headlessCommand !== "function")
                         return { verdict: v(false, "headless probe unavailable"), timedOut: false };
@@ -455,8 +461,11 @@ export async function probeModels(cfg, repoRoot, adapters, health, onProgress) {
                             return { verdict: v(true), timedOut: false };
                         if (!retry)
                             return { verdict: null, timedOut: r.timedOut === true };
+                        const error = probeError(r.code, r.stdout, r.stderr, r.timedOut);
                         return {
-                            verdict: r.timedOut && retry.firstTimedOut ? v(false, `probe timed out twice (${MODEL_PROBE_TIMEOUT_MS}ms)`) : v(false, reason),
+                            verdict: error
+                                ? v(priorModelAuth?.[model]?.authed === true, undefined, error)
+                                : r.timedOut && retry.firstTimedOut ? v(false, `probe timed out twice (${MODEL_PROBE_TIMEOUT_MS}ms)`) : v(false, reason),
                             timedOut: r.timedOut === true,
                         };
                     }
@@ -605,7 +614,7 @@ export function modelAuthExclusions(cfg, adapters, health) {
             if (modelAuthed(h, c.model, cfg.routing.allowUnverifiedModels))
                 continue;
             if (v?.authed === false)
-                out.push({ key: channelKey(c), adapter: a.id, reason: v.reason ?? "probe failed", probedAt: v.probedAt });
+                out.push({ key: channelKey(c), adapter: a.id, reason: v.probeError ? `probe-error (${v.probeError})` : v.reason ?? "probe failed", probedAt: v.probedAt });
             else
                 out.push({ key: channelKey(c), adapter: a.id, reason: "no model auth verdict — run tickmarkr doctor", probedAt: "not recorded" });
         }

package/dist/adapters/types.d.ts

@@ -23,9 +23,12 @@ export interface BillingChannel {
     channel: "sub" | "api";
     tier: Tier;
 }
+export declare const MODEL_PROBE_ERRORS: readonly ["EMFILE", "EAGAIN", "ENFILE", "ENOMEM", "ENOSPC"];
+export type ModelProbeError = typeof MODEL_PROBE_ERRORS[number];
 export interface ModelAuth {
     authed: boolean;
     reason?: string;
+    probeError?: ModelProbeError;
     probedAt: string;
 }
 export interface AuthHealth {

package/dist/adapters/types.js

@@ -23,6 +23,7 @@ export function addUsage(a, b) {
         reasoning: add(a.reasoning, b.reasoning),
     };
 }
+export const MODEL_PROBE_ERRORS = ["EMFILE", "EAGAIN", "ENFILE", "ENOMEM", "ENOSPC"];
 export function modelAuthed(health, model, allowUnverifiedModels = false) {
     const authed = health?.modelAuth?.[model]?.authed;
     return authed === true || (authed === undefined && allowUnverifiedModels);

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

@@ -9,19 +9,15 @@ export type ApprovalDisposition = (typeof APPROVAL_DISPOSITIONS)[number];
 export declare const APPROVAL_ENACTS: Record<ApprovalDisposition, string>;
 export declare function approvalDispositionForRelease(release: unknown): ApprovalDisposition;
 export type ApprovalStatus = "deferred-live" | "recorded-no-owner";
-/** Which run, and whether a LIVE daemon owns THAT run — the two facts an enactment sentence needs. */
+/** The requested run plus the different live run currently blocking its repository, when present. */
 export interface ApprovalRunOwner {
     runId: string;
     live: boolean;
+    blockingRunId?: string;
 }
 /** The same read `approve` performs, for surfaces that must predict an enactment before writing. */
 export declare function approvalRunOwner(cwd: string, runId: string): ApprovalRunOwner;
-/**
- * The one sentence that says who enacts this release and what it buys. A live owner's approval is
- * already scheduled — it rides that daemon's next task boundary — so it must NOT be told to resume:
- * a second run in the same repository is forbidden, and it would contend for the live daemon's
- * graph.lock over an approval that has already dispatched.
- */
+/** The one sentence that says who enacts this release and what it buys. */
 export declare function approvalEnactment(token: ApprovalDisposition, run: ApprovalRunOwner): string;
 /** The production command registered in COMMANDS; its returned bytes are what the CLI prints. */
 export declare function approve(argv: string[], cwd?: string): Promise<string>;

package/dist/cli/commands/approve.js

@@ -32,21 +32,27 @@ import { acquireApprovalSerialization, runLockOwner } from "../../run/lock.js";
 // falsehood in a new shape. Liveness itself comes from lock.ts's runLockOwner (the same inspect() the
 // acquire/unlock decision table uses), never a second `process.kill(pid, 0)`, and never the lock
 // FILE's presence: a stale lock whose recorded pid is dead is not a live run.
-const ownedByLiveDaemon = (owner, runId) => ({ runId, live: owner?.live === true && owner.runId === runId });
+const ownedByLiveDaemon = (owner, runId) => {
+    const run = { runId, live: owner?.live === true && owner.runId === runId };
+    if (owner?.live === true && owner.runId !== undefined && owner.runId !== runId) {
+        // Preserve the shipped enumerable { runId, live } shape while carrying the third state.
+        Object.defineProperty(run, "blockingRunId", { value: owner.runId });
+    }
+    return run;
+};
 /** The same read `approve` performs, for surfaces that must predict an enactment before writing. */
 export function approvalRunOwner(cwd, runId) {
     return ownedByLiveDaemon(runLockOwner(cwd), runId);
 }
-/**
- * The one sentence that says who enacts this release and what it buys. A live owner's approval is
- * already scheduled — it rides that daemon's next task boundary — so it must NOT be told to resume:
- * a second run in the same repository is forbidden, and it would contend for the live daemon's
- * graph.lock over an approval that has already dispatched.
- */
+/** The one sentence that says who enacts this release and what it buys. */
 export function approvalEnactment(token, run) {
-    return run.live
-        ? `the live daemon enacts this at its next task boundary — it will ${APPROVAL_ENACTS[token]}`
-        : `run \`tickmarkr resume ${run.runId}\` to ${APPROVAL_ENACTS[token]}`;
+    if (run.live) {
+        return `the live daemon enacts this at its next task boundary — it will ${APPROVAL_ENACTS[token]}`;
+    }
+    if (run.blockingRunId) {
+        return `release recorded; live run \`${run.blockingRunId}\` holds the repository lock, so resume \`${run.runId}\` after it ends to ${APPROVAL_ENACTS[token]}`;
+    }
+    return `run \`tickmarkr resume ${run.runId}\` to ${APPROVAL_ENACTS[token]}`;
 }
 /** The production command registered in COMMANDS; its returned bytes are what the CLI prints. */
 export async function approve(argv, cwd = process.cwd()) {
@@ -153,12 +159,12 @@ export async function approve(argv, cwd = process.cwd()) {
 //
 // The ENACTMENT half of the message is completed here because only here is liveness known: the call
 // sites carry the decision, not the answer to who will act on it. `deferred-live` keeps its v1.89
-// token — machine consumers parse it — while its TEXT now names the boundary sweep, and the `resume`
-// field it used to carry unconditionally is withheld from the live branch it would misdirect.
+// token — machine consumers parse it — while its TEXT now names the boundary sweep. A recovery
+// command is emitted only with no live repository owner; a different run's live owner instead names
+// the blocker and waits until it ends.
 function disposition(cwd, runId, token, message, contended) {
     const owner = runLockOwner(cwd);
     const run = ownedByLiveDaemon(owner, runId);
-    const resume = `tickmarkr resume ${runId}`;
     const out = `approval disposition ${token}: ${message}; ${approvalEnactment(token, run)}`;
     if (!owner && !contended)
         return out;
@@ -166,9 +172,8 @@ function disposition(cwd, runId, token, message, contended) {
     const record = {
         status,
         disposition: token,
-        // The recovery command is claimed only where it IS the enactment. A live owner's approval is
-        // already scheduled, and a resume would contend for that daemon's graph.lock.
-        ...(run.live ? {} : { resume }),
+        // Resume is safe to prescribe only when no live repository owner would contend with it.
+        ...(!run.live && !run.blockingRunId ? { resume: `tickmarkr resume ${runId}` } : {}),
         ...(owner?.pid === undefined ? {} : { ownerPid: owner.pid }),
         ...(owner?.runId === undefined ? {} : { ownerRunId: owner.runId }),
     };

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

@@ -25,7 +25,7 @@ export type DoctorOpts = {
     listTests?: (cwd: string) => Promise<VitestListResult>;
 };
 type OrcaCapability = {
-    verdict: "pass" | "fail";
+    verdict: "pass" | "fail" | "warn";
     detail: string;
 };
 /**

package/dist/cli/commands/doctor.js

@@ -12,7 +12,7 @@ import { graphPath, loadGraph, tickmarkrDir, stateDirName } from "../../graph/gr
 import { catalogModelAdvisory, catalogTierRanking, declaredModelWindow, hasWindowsConfig, modelLints, suggestOverlay, ttyVisual } from "../../adapters/model-lints.js";
 import { loadConfig, overlayPreferShapes } from "../../config/config.js";
 import { HerdrDriver } from "../../drivers/herdr.js";
-import { parseEnvelope } from "../../drivers/orca.js";
+import { ORCA_FIXTURE_VERSION, parseEnvelope, resolveOrcaCliBinary } from "../../drivers/orca.js";
 import { kimi, probeKimiDoctorTurn } from "../../adapters/kimi.js";
 import { denyPreferCollisionLine, denyPreferCollisions, disallowedBy, excludedChannels, exclusionLine, preferRanks } from "../../route/preference.js";
 import { LIVEBENCH_TABLE_DATE, readCachedCatalog, refreshCatalogCommand } from "../../adapters/catalog-remote.js";
@@ -34,7 +34,9 @@ const attentionRow = (text) => `  ${statusRow("warn", text)}`;
  * stderr (Electron timestamps), so the row is byte-stable across runs.
  */
 export async function probeOrcaCapability(cwd, opts = {}) {
-    const binary = opts.resolveOrcaBinary ? opts.resolveOrcaBinary(cwd) : resolveShellBinary("orca", cwd).resolved;
+    const binary = opts.resolveOrcaBinary
+        ? opts.resolveOrcaBinary(cwd)
+        : resolveOrcaCliBinary(cwd, { resolve: (bin, dir) => resolveShellBinary(bin, dir) });
     if (!binary)
         return { verdict: "fail", detail: "CLI not installed" };
     let response;
@@ -60,8 +62,16 @@ export async function probeOrcaCapability(cwd, opts = {}) {
         const reachable = typeof runtime === "object" && runtime !== null && !Array.isArray(runtime)
             ? runtime.reachable
             : undefined;
-        if (reachable === true)
-            return { verdict: "pass", detail: `runtime reachable (${envelope.runtimeId})` };
+        if (reachable === true) {
+            const appVersion = typeof runtime === "object" && runtime !== null && !Array.isArray(runtime)
+                ? runtime.appVersion
+                : undefined;
+            if (typeof appVersion !== "string" || !appVersion) {
+                return { verdict: "warn", detail: `runtime reachable (${envelope.runtimeId}, appVersion absent; fixture pin ${ORCA_FIXTURE_VERSION})` };
+            }
+            const detail = `runtime reachable (${envelope.runtimeId}, appVersion ${appVersion}; fixture pin ${ORCA_FIXTURE_VERSION})`;
+            return { verdict: appVersion === ORCA_FIXTURE_VERSION ? "pass" : "warn", detail };
+        }
         if (reachable === false)
             return { verdict: "fail", detail: "CLI installed but runtime unreachable" };
         return { verdict: "fail", detail: "CLI installed but runtime probe failed — status carries no reachability proof" };

package/dist/cli/commands/plan.js

@@ -17,6 +17,7 @@ import { loadRoutingProfile } from "../../run/journal.js";
 import { harnessLine, resolveHarness } from "../harness.js";
 import { shq } from "../../adapters/types.js";
 import { shGit } from "../../run/git.js";
+import { driverEvidence, pickDriver } from "../../drivers/index.js";
 // T4 (v1.50): TTY-only brand pass — the title helper frames the routing table, lint/unroutable
 // markers carry the attention glyph, section labels dim to chrome (the doctor/status system).
 // Gated on ttyVisual(): the non-TTY surface returns untouched (byte-pinned, machine-consumable).
@@ -99,7 +100,7 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
     const DOCTOR_STALE_MS = 24 * 60 * 60 * 1000;
     // v1.51 T2: plan previews any mode without a config edit — same source precedence as run
     // (flag > spec front-matter > repo > global > default), same preset compiler.
-    const { values } = parseArgs({ args: argv, options: { mode: { type: "string" } }, allowPositionals: true });
+    const { values } = parseArgs({ args: argv, options: { mode: { type: "string" }, driver: { type: "string" } }, allowPositionals: true });
     if (values.mode !== undefined && !ROUTING_MODES.includes(values.mode)) {
         throw new Error(`--mode must be one of ${ROUTING_MODES.join(" | ")} (got ${values.mode})`);
     }
@@ -136,6 +137,7 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
         inputRefusals.set(finding.taskId, [...(inputRefusals.get(finding.taskId) ?? []), finding.detail]);
     }
     const { cfg, mode, source } = resolveRunMode(cwd, { flag: values.mode, spec: g.mode });
+    const selectedDriver = pickDriver(cfg, values.driver);
     // readDoctor cache path: staleness line only fires here (probeAll fallback is fresh by construction).
     const cached = readDoctor(cwd);
     const health = cached ?? (await probeAll(adapters));
@@ -157,6 +159,7 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
     const lines = [
         `tickmarkr plan — dry run (${channels.length} channels available)`,
         `mode: ${mode.mode} (${source}) · explore ${cfg.routing.explore?.mode ?? "on"}`,
+        `driver: ${driverEvidence(cfg, selectedDriver, values.driver)}`,
         harnessLine(resolveHarness(harnessFrom)),
         "",
     ];

package/dist/cli/commands/verify.js

@@ -205,6 +205,8 @@ export async function verify(argv, cwd = process.cwd()) {
         onGate: (e) => {
             if (e.phase === "start")
                 console.error(`verify: → ${e.gate} (${e.index}/${e.total})`);
+            else if (e.phase === "note")
+                console.error(`verify: note ${e.gate} ${e.name} ${JSON.stringify(e.payload)}`);
             else
                 console.error(`verify: ${e.result.pass ? "✓" : "✗"} ${e.result.gate} — ${e.result.details.split("\n")[0] ?? ""}`);
         },

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

@@ -1 +1,2 @@
-export declare function version(_argv?: string[]): Promise<string>;
+export declare function distFingerprint(dir?: string): string;
+export declare function version(argv?: string[], dir?: string): Promise<string>;

package/dist/cli/commands/version.js

@@ -1,8 +1,29 @@
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "../../../package.json");
-export async function version(_argv = []) {
+const distDir = join(dirname(pkgPath), "dist");
+export function distFingerprint(dir = distDir) {
+    if (!existsSync(dir))
+        return "missing";
+    const files = [];
+    const visit = (path) => {
+        for (const entry of readdirSync(path, { withFileTypes: true })) {
+            const child = join(path, entry.name);
+            if (entry.isDirectory())
+                visit(child);
+            else if (entry.isFile())
+                files.push(child);
+        }
+    };
+    visit(dir);
+    const hash = createHash("sha256");
+    for (const file of files.sort())
+        hash.update(relative(dir, file)).update("\0").update(readFileSync(file)).update("\0");
+    return hash.digest("hex");
+}
+export async function version(argv = [], dir = distDir) {
     const { version: v } = JSON.parse(readFileSync(pkgPath, "utf8"));
-    return v;
+    return argv.includes("--dist") ? `${v} dist:${distFingerprint(dir)}` : v;
 }

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;

package/dist/gates/run-gates.js

@@ -583,6 +583,14 @@ export async function runGates(task, ctx) {
         // eligible seat keeps the ORIGINAL result so the recorded cause stays truthful (OBS-196).
         if (rv.meta?.unparseable === true && typeof rv.meta.reviewer === "string") {
             const flaked = rv.meta.reviewer;
+            const emptyOutput = rv.meta.cause === "empty-output";
+            if (emptyOutput) {
+                await ctx.onGate?.({
+                    phase: "note", gate: "review", name: "reviewer-empty-output",
+                    payload: { reviewer: flaked, bytes: typeof rv.meta.bytes === "number" ? rv.meta.bytes : 0 },
+                    result: { ...rv, meta: { ...rv.meta, skipped: true } },
+                });
+            }
             const retryVia = ctx.via
                 ? { ...ctx.via, nameFor: (role, adapter) => ctx.via.nameFor(role, adapter) + "-r1" }
                 : undefined;
@@ -593,7 +601,7 @@ export async function runGates(task, ctx) {
                     ...second,
                     // `details` is lifted onto the journal's gate-result row; meta.reviewRetry is not. Keep the
                     // re-route visible in the result text a reader actually opens, including on a red retry.
-                    details: `review re-route: ${flaked} produced no parseable verdict; replaced by ${retried}\n${second.details}`,
+                    details: `review re-route: ${flaked} produced ${emptyOutput ? "EMPTY output" : "no parseable verdict"}; replaced by ${retried}\n${second.details}`,
                     meta: { ...second.meta, reviewRetry: { flaked, retried } },
                 };
             }

package/dist/run/consult.d.ts

@@ -9,6 +9,9 @@ export interface ConsultVerdict {
     reason?: string;
     guidance?: string;
     excludeAdapter?: string;
+    adapter?: string;
+    model?: string;
+    vendor?: string;
 }
 export declare function renderRetryGuidance(v: ConsultVerdict): string;
 export declare function augmentRetryBrief(feedback: string, opts: {
@@ -36,5 +39,9 @@ export declare function consult(d: Dossier, cfg: TickmarkrConfig, adapters: Work
     runId?: string;
     channels?: Array<{
         adapter: string;
+        model?: string;
+        vendor?: string;
+        channel?: "sub" | "api";
+        tier?: string;
     }>;
 }): Promise<ConsultVerdict>;

package/dist/run/consult.js

@@ -205,6 +205,17 @@ opts = {}) {
     // the same rule as every prefer entry — and disallowedBy carries the full deny grammar (adapter,
     // model, or adapter:model), so a model-scoped deny cannot slip past an adapter-id-only read.
     const allowedSeats = seats.filter((s) => disallowedBy(s, cfg.routing, "consult") === null);
+    const seatIdentity = (seat) => {
+        let vendor = opts.channels?.find((candidate) => candidate.adapter === seat.adapter && candidate.model === seat.model)?.vendor;
+        if (!vendor) {
+            try {
+                const adapter = getAdapter(seat.adapter, adapters);
+                vendor = adapter.channels(cfg).find((channel) => channel.model === seat.model)?.vendor ?? adapter.vendor;
+            }
+            catch { /* an unknown adapter still gets explicit unknown provenance */ }
+        }
+        return { adapter: seat.adapter, model: seat.model, vendor: vendor ?? "unknown" };
+    };
     if (!allowedSeats.length) {
         const d = disallowedBy(seats[seats.length - 1], cfg.routing, "consult");
         return {
@@ -216,11 +227,14 @@ opts = {}) {
         try {
             const parsed = await invokeSeat(seat.adapter, seat.model, i);
             if (parsed.verdict)
-                return parsed.verdict;
+                return { ...parsed.verdict, ...seatIdentity(seat) };
         }
         catch {
             // failed seat (unknown adapter, dead driver/pane, shell error) — fall to the next entry
         }
     }
-    return { action: "human", notes: "consult verdict unparseable — failing safe to human" };
+    return {
+        action: "human",
+        notes: "consult verdict unparseable — failing safe to human",
+    };
 }

package/dist/run/daemon.d.ts

@@ -1,5 +1,6 @@
 import { type WorkerAdapter } from "../adapters/types.js";
 import { type ModeResolution, type RoutingMode, type TickmarkrConfig } from "../config/config.js";
+import { type DriverChoice } from "../drivers/index.js";
 import { type ExecutorDriver } from "../drivers/types.js";
 import { type Baseline } from "../gates/baseline.js";
 import type { GateResult } from "../gates/types.js";
@@ -13,6 +14,7 @@ export interface RunOptions {
     retryFailed?: boolean;
     concurrency?: number;
     driver?: ExecutorDriver;
+    driverOverride?: DriverChoice;
     adapters?: WorkerAdapter[];
     globalDir?: string;
     mode?: RoutingMode;

package/dist/run/daemon.js

@@ -12,6 +12,7 @@ import { bannerShell, paneDispatchCommand } from "../brand.js";
 import { collateralHits } from "../compile/collateral.js";
 import { DEFAULT_DIFF_CAP, globalConfigDir, loadConfigWithMode, readOverlayFile, repoOverlayPath, } from "../config/config.js";
 import { DeliveryReadinessError } from "../drivers/herdr.js";
+import { driverEvidence } from "../drivers/index.js";
 import { herdrSealShellPrefix, SubprocessDriver } from "../drivers/subprocess.js";
 import { formatOwnedName } from "../drivers/types.js";
 import { captureBaseline, detectGateCommands, detectVacuousOracles } from "../gates/baseline.js";
@@ -19,6 +20,7 @@ import { runGates } from "../gates/run-gates.js";
 import { filesGlob } from "../graph/files-glob.js";
 import { addEvidence, attributeBlocked, blockedTasks, getTask, graphDefinitionHash, loadGraph, pendingTasks, readyTasks, saveGraph, setStatus, taskContentDigest, tickmarkrDir } from "../graph/graph.js";
 import { GATE_NAMES } from "../graph/schema.js";
+import { distFingerprint } from "../cli/commands/version.js";
 import { augmentRetryBrief, consult, renderRetryGuidance } from "./consult.js";
 import { runEnvironment } from "./environment.js";
 import { cleanupRunWorktrees, gitHead, linkNodeModules, npmDependencyInstallCommand, npmDependencyManifestChanged, preserveWorktree, resolvedCapacity, runWithForkBudget, sameCapacity, sh, shGit, WORKTREE_LAYOUT_CONTRACT, worktreePath } from "./git.js";
@@ -1255,11 +1257,25 @@ export async function runDaemon(repoRoot, opts = {}) {
                 baseRef = await gitHead(repoRoot);
                 baseline = await captureBaseline(repoRoot, commands);
                 writeFileSync(join(journal.dir, "baseline.json"), JSON.stringify(baseline, null, 2));
+                writeFileSync(join(journal.dir, "graph.json"), readFileSync(join(tickmarkrDir(repoRoot), "graph.json")));
                 // v1.70 T2: environment identity beside the graph/branch identity — running tickmarkr version,
                 // loaded-config hash, and the probed CLI version of each adapter holding a channel in the run,
                 // gathered through the existing probe/config-load paths (no second mechanism).
                 const environment = runEnvironment(cfg, channels, health);
-                journal.append("run-start", undefined, { pid: process.pid, baseRef, commands, channels: channels.map(channelKey), branch, graphDefinitionHash: graphDefinitionHash(graph), mode: rm.mode.mode, modeSource: rm.source, environment, ...(prior ? { supersedes: prior.runId } : {}) }); // graphDefinitionHash: T3 engagement identity (status+resume share it); pid: v1.13 (VIS-11) liveness; mode/modeSource: v1.51 T2; supersedes: v1.53 T5
+                journal.append("run-start", undefined, {
+                    pid: process.pid, baseRef, commands, channels: channels.map(channelKey),
+                    channelsByRole: {
+                        worker: pools.worker.map(channelKey),
+                        judge: pools.judge.map(channelKey),
+                        review: pools.review.map(channelKey),
+                        consult: pools.consult.map(channelKey),
+                    },
+                    driver: driver.id,
+                    driverEvidence: driverEvidence(cfg, driver, opts.driverOverride),
+                    distFingerprint: distFingerprint(),
+                    branch, graphDefinitionHash: graphDefinitionHash(graph), mode: rm.mode.mode, modeSource: rm.source,
+                    environment, ...(prior ? { supersedes: prior.runId } : {}),
+                }); // graphDefinitionHash: T3 engagement identity (status+resume share it); pid: v1.13 (VIS-11) liveness; mode/modeSource: v1.51 T2; supersedes: v1.53 T5
                 runStarted = true;
                 // v1.53 T5: mark the prior run AFTER this run's run-start exists, so the prior journal never
                 // names a successor that has no journal. Append-only — the prior journal is never rewritten.
@@ -1786,6 +1802,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                 const applyVerdict = async (v, attempts, trigger) => {
                     journal.append("consult-verdict", t.id, {
                         action: v.action, notes: v.notes,
+                        adapter: v.adapter ?? "unknown", model: v.model ?? "unknown", vendor: v.vendor ?? "unknown",
                         ...(v.reason ? { reason: v.reason } : {}),
                         ...(v.guidance ? { guidance: v.guidance } : {}),
                         ...(v.excludeAdapter ? { excludeAdapter: v.excludeAdapter } : {}),
@@ -2009,6 +2026,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     journal.phaseStart(t.id, phaseForGate(e.gate), { gate: e.gate, index: e.index, total: e.total, ...(e.parentAt === undefined ? {} : { parallel: true }) });
                                     return;
                                 }
+                                if (e.phase === "note") {
+                                    journal.append(e.name, t.id, e.payload);
+                                    return;
+                                }
                                 const g = e.result;
                                 inParallelOrder(g.gate, () => {
                                     journalGateResult(g);
@@ -3452,6 +3473,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                             journal.phaseStart(t.id, phaseForGate(e.gate), { gate: e.gate, index: e.index, total: e.total, ...(e.parentAt === undefined ? {} : { parallel: true }) });
                             return;
                         }
+                        if (e.phase === "note") {
+                            journal.append(e.name, t.id, e.payload);
+                            return;
+                        }
                         const g = e.result;
                         inParallelOrder(g.gate, () => {
                             // GATE-09 (ROADMAP SC-4): journal every judge retry as an attributable event — which gate flaked,
@@ -3654,7 +3679,11 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 continue;
                             return;
                         }
-                        journal.append("consult-verdict", t.id, { action: v.action, notes: v.notes, capAdvisory: true });
+                        journal.append("consult-verdict", t.id, {
+                            action: v.action, notes: v.notes,
+                            adapter: v.adapter ?? "unknown", model: v.model ?? "unknown", vendor: v.vendor ?? "unknown",
+                            capAdvisory: true,
+                        });
                     }
                     // v1.85 T3: a narrow battery over fully carried commits earns a REPAIR (decided above) — the
                     // next dispatch carries the findings verbatim and the diff content instead of re-onboarding a

package/package.json

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

package/skills/tickmarkr-loop/SKILL.md

@@ -29,6 +29,7 @@ Outside a multi-agent terminal environment, run the loop directly.
 - Do not edit the compiled graph to force an outcome; fix the source spec and compile again.
 - Gates verify commits, diffs, acceptance criteria, and reviews independently. Never trust a worker's claim that work is complete.
 - Treat missing or unparseable machine results and verdicts as failures. Do not release, resume, or merge around failed gates.
+- A task changing what the daemon DOES must own every surface that TELLS the operator what the daemon does.
 
 ## Act by default
 

package/skills/tickmarkr-overseer/SKILL.md

@@ -755,6 +755,10 @@ once** — an overseer ran nine hours at 86% unable to read its own number. Arm
 Herdr's `agent_status`, which is unreliable for vendors whose screen detection is skipped (kimi) — for
 those, the spawn-time auto-approve flag is the control, not this watcher.
 
+For `consult`, `surgeon`, and `reviewer` seats, the CONTEXT watcher is wake-only: arm it with
+`TKR_AUTO_CLEAR=0 .claude/skills/tickmarkr-overseer/scripts/watch-context.sh <consult|surgeon|reviewer>
+<agent|pane> 50 50 <handoff-file>`. Only `orchestrator` and `overseer` seats may use auto-clear.
+
 ```bash
 .claude/skills/tickmarkr-overseer/scripts/watch-pending-input.sh <agent|pane> [poll-s] [cap-s] [confirm-polls]
 ```
@@ -953,6 +957,13 @@ orchestrator turn boundary.
    leave clean state after a version is shipped"***. Every line below is a defect that actually happened
    on the release that produced this rule.
 
+   - **RUN BOTH RELEASE PROOFS BEFORE STANDING DOWN.** The first is the exported-tree suite, which
+     maintainers run from the private repo with its `verify:export` script — that tooling is deliberately
+     not part of this package, so the command does not exist in a public checkout; it must install,
+     build, and run the suite in the exported tree; then
+     `TICKMARKR_E2E=1 npx vitest run tests/e2e/orca-smoke.e2e.test.ts` must exercise the installed-Orca
+     smoke. A skipped smoke is not proof. Record both results before declaring the release complete.
+
    - **REWRITE THE MEMORY INDEX FIRST, and read it back.** Minutes after `2.1.1` hit npm, the index line
      a fresh session loads still read *"⛔ 2.1.1 CANNOT ship from run …2011"* — true when written, and by
      then the exact opposite of the truth. **The index is what everyone loads and the body is what nobody

package/skills/tickmarkr-overseer/scripts/watch-context.sh

@@ -33,7 +33,7 @@
 # usage: watch-context.sh <role-slug> <agent|pane> <warn-pct> <act-pct> [handoff-file] [poll-s] [cap-s]
 #   <role-slug> is ANY seat role — orchestrator, overseer, surgeon, consult — and names the tier
 #   `<role>-context`. It is deliberately NOT a closed set: see OBS-730 at the guard below.
-#   TKR_AUTO_CLEAR=1   at act-pct WITH a fresh handoff, send /clear and re-brief instead of waking.
+#   TKR_AUTO_CLEAR=1   at act-pct WITH a fresh handoff, auto-clear orchestrator/overseer; other roles wake only.
 #   TKR_REBRIEF=<path> the file the re-briefed seat is told to read (defaults to the handoff).
 #   TKR_HANDOFF_MAX_AGE_S  how fresh "fresh" is (default 900).
 #   TKR_CLEAR_SETTLE_S     seconds to let a cleared seat settle before the re-brief (default 6).
@@ -221,7 +221,7 @@ handoff_fresh() {
 act_on() {
   local P="$1"
   if handoff_fresh; then
-    if [ "${TKR_AUTO_CLEAR:-0}" = "1" ]; then
+    if [ "${TKR_AUTO_CLEAR:-0}" = "1" ] && { [ "$ROLE" = "orchestrator" ] || [ "$ROLE" = "overseer" ]; }; then
       herdr agent prompt "$TARGET" "/clear" >/dev/null 2>&1
       sleep "$SETTLE"
       herdr agent prompt "$TARGET" "Read ${REBRIEF} and continue exactly where it says. Your context was cleared at ${P}% against that handoff; it is current as of $(date '+%H:%M'). Do not reconstruct from memory — everything you need is on disk." >/dev/null 2>&1