tickmarkr 2.2.0 → 2.3.0

package/README.md

@@ -13,8 +13,9 @@ tickmarkr is a spec-driven orchestration harness for AI coding agent CLIs. You w
 acceptance criteria; the engine routes tasks to the best installed agent CLI (claude-code, codex,
 cursor-agent, opencode, grok, pi, kimi) by cost and capability, dispatches work in git worktrees for
 change isolation — as interactive TUIs when running under [herdr](https://herdr.dev), headless
-subprocesses otherwise, or in [Orca](https://onorca.dev) terminals when you name that driver
-yourself — and independently verifies each committed result by checking for no new
+subprocesses otherwise, or in [Orca](https://onorca.dev) terminals when auto detects both Orca
+markers (name that driver explicitly outside one) — and independently verifies each committed
+result by checking for no new
 baseline failures per task, then strictly verifying the integration tip. Green tasks consolidate onto a
 `tickmarkr/<runId>` branch; merging to your mainline is always your call, never automated. Engage
 with full visibility into routing decisions, worker progress, and gate verdicts — or run headless
@@ -251,14 +252,14 @@ and first-attempt success rate. Cost reporting follows strict honesty rules and
 When running under [herdr](https://herdr.dev), tickmarkr creates a labeled pane-and-tab workspace
 for real-time visibility (optional — omit `--driver herdr` or run headless if preferred).
 
-### Orca: an explicit-selection execution surface
+### Orca: a detected-or-named execution surface
 
-[Orca](https://onorca.dev) is the third execution surface, and the only one you must ask for by
-name: `--driver orca` or `driver: orca` in config. `--driver auto` never selects it — auto picks
-herdr when a herdr session is live and subprocess otherwise — so Orca is never inherited from an
-ambient environment variable, and an Orca that is installed but unreachable is not silently
-downgraded to a hidden subprocess worker either. Naming it is the whole gate; its runtime failures
-stay Orca's, reported as failures.
+[Orca](https://onorca.dev) is the third execution surface. `auto` resolves herdr first when
+`HERDR_ENV=1`, then Orca only when both Orca-authored markers `TERM_PROGRAM=Orca` and
+`ORCA_TERMINAL_HANDLE` are present, then subprocess. This environment-only choice executes no
+binary or runtime probe. Outside an Orca terminal, name it explicitly with `--driver orca` or
+`driver: orca` in config. Once selected either way, an unreachable Orca stays a loud Orca driver
+failure and is never silently replaced by a hidden subprocess worker.
 
 What Orca supplies is terminals. What tickmarkr keeps is everything that decides whether work
 ships: **it creates and owns the git worktree** for every task (Orca is told which checkout to bind

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 {
@@ -113,7 +116,23 @@ export declare const TrustDialogSchema: z.ZodUnion<readonly [z.ZodObject<{
     reason: z.ZodString;
 }, z.core.$strict>]>;
 export declare function matchesTrustDialog(paneText: string, dialog: TrustDialog): dialog is CapturedTrustDialog;
+export declare const ADAPTER_PROMPT_GLYPHS: {
+    readonly "claude-code": "❯";
+    readonly codex: "›";
+    readonly "cursor-agent": ">";
+    readonly opencode: ">";
+    readonly pi: ">";
+    readonly grok: ">";
+    readonly kimi: ">";
+    readonly omp: ">";
+    readonly agy: ">";
+    readonly "prime-agent": ">";
+    readonly fake: ">";
+};
+export type PromptGlyph = (typeof ADAPTER_PROMPT_GLYPHS)[keyof typeof ADAPTER_PROMPT_GLYPHS];
+export declare function declaredPromptGlyphForAdapter(adapterId: string): PromptGlyph | undefined;
 export interface InputBox {
+    promptGlyph?: PromptGlyph;
     fingerprint: string;
     match?(paneText: string): boolean;
     emptyMatch?(paneText: string): boolean;
@@ -121,8 +140,11 @@ export interface InputBox {
     launchCommand?(command: string): boolean;
     readinessTimeoutMs?: number;
 }
-export declare function declareInputBox(adapterId: string, inputBox: InputBox): InputBox;
+export declare function declareInputBox(adapterId: string, inputBox: Omit<InputBox, "promptGlyph"> & {
+    promptGlyph?: PromptGlyph;
+}): InputBox;
 export declare function declaredInputBoxForWorkerName(workerName: string): InputBox | undefined;
+export declare function declaredPromptGlyphForWorkerName(workerName: string): PromptGlyph | undefined;
 export declare function matchesInputBox(paneText: string, inputBox: InputBox): boolean;
 export declare function matchesEmptyInputBox(paneText: string, inputBox: InputBox): boolean;
 export declare function matchesOccupiedInputBox(paneText: string, inputBox: InputBox): boolean;

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);
@@ -128,15 +129,55 @@ export function matchesTrustDialog(paneText, dialog) {
         return false;
     return dialog.fingerprint.trim().length > 0 && paneText.includes(dialog.fingerprint);
 }
+// v1.75 T1 / OBS-136: an adapter whose steady-state TUI presents a bordered input box declares
+// one distinctive pane-text fingerprint. The herdr driver associates declarations with worker
+// slots by the existing adapter-bearing dispatch name before that name is canonicalized.
+// v1.77 / OBS-142: launchCommand identifies the adapter-owned bootstrap command that necessarily
+// precedes the box; that command settles on a clean shell line, while every other delivery waits
+// for the declared box itself. readinessTimeoutMs bounds that evidence loop per adapter.
+// v1.85 T5 / OBS-140: typed delivery is licensed by DECLARED states, never by transcript shape.
+// `match` is the box painted, `emptyMatch` the box carrying nothing, `occupiedMatch` the box still
+// holding a prompt. An adapter may pin `occupiedMatch` directly, or leave it derived from the other
+// two — but an adapter that declares neither cannot acknowledge a submission and is refused.
+// OBS-620: prompt glyphs are adapter facts, just like the input-box matchers below. Keep the shipped
+// set in one shell-readable table: the overseer receipt cannot import TypeScript, but it reads these
+// exact declarations from src/ in a checkout or dist/ in an installed package. A newly shipped
+// adapter therefore has one visible place where omission can be enumerated and refused.
+export const ADAPTER_PROMPT_GLYPHS = {
+    "claude-code": "❯",
+    "codex": "›",
+    "cursor-agent": ">",
+    "opencode": ">",
+    "pi": ">",
+    "grok": ">",
+    "kimi": ">",
+    "omp": ">",
+    "agy": ">",
+    "prime-agent": ">",
+    // Test-only, but declared so a fake interactive slot exercises the same fail-closed contract.
+    "fake": ">",
+};
+export function declaredPromptGlyphForAdapter(adapterId) {
+    return ADAPTER_PROMPT_GLYPHS[adapterId];
+}
 const inputBoxes = new Map();
 export function declareInputBox(adapterId, inputBox) {
-    inputBoxes.set(adapterId, inputBox);
-    return inputBox;
+    const promptGlyph = inputBox.promptGlyph ?? declaredPromptGlyphForAdapter(adapterId);
+    // The shipped-adapter registry is audited separately against ADAPTER_PROMPT_GLYPHS. Keep this
+    // declaration helper open to synthetic and extension adapters: Herdr's input-state tests register
+    // those at module load, and prompt glyphs are not part of its typed-delivery decision.
+    const declared = promptGlyph === undefined ? inputBox : { ...inputBox, promptGlyph };
+    inputBoxes.set(adapterId, declared);
+    return declared;
 }
 export function declaredInputBoxForWorkerName(workerName) {
     const adapterId = /^.+-worker-(.+)-a\d+-.+$/.exec(workerName)?.[1];
     return adapterId === undefined ? undefined : inputBoxes.get(adapterId);
 }
+export function declaredPromptGlyphForWorkerName(workerName) {
+    const adapterId = /^.+-worker-(.+)-a\d+-.+$/.exec(workerName)?.[1];
+    return adapterId === undefined ? undefined : declaredPromptGlyphForAdapter(adapterId);
+}
 export function matchesInputBox(paneText, inputBox) {
     return inputBox.match?.(paneText) ?? paneText.includes(inputBox.fingerprint);
 }

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

@@ -11,7 +11,7 @@ export const APPROVAL_DISPOSITIONS = ["dispatch", "waive-gate", "re-dispatch", "
 export const APPROVAL_ENACTS = {
     dispatch: "dispatch it",
     "waive-gate": "continue past the approved gate",
-    "re-dispatch": "re-dispatch against the full gate suite",
+    "re-dispatch": "re-dispatch against the full gate suite only if re-running the whole declared battery on the parked commit before any worker is red",
     "fund-fixed-attempt": "dispatch a fixed attempt carrying the findings",
     "fresh-budget": "dispatch it on a fresh attempt budget",
 };
@@ -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()) {
@@ -79,6 +85,7 @@ export async function approve(argv, cwd = process.cwd()) {
         const lastHuman = events[lastHumanIndex];
         const capPark = lastHuman?.data.kind === ATTEMPT_CAP_RELEASE;
         const gateFailPark = lastHuman?.data.kind === "gate-fail";
+        const infraPark = lastHuman?.data.kind === "infra";
         const failedGate = gateFailPark ? failedGateForNewestPark(events, taskId, lastHumanIndex) : undefined;
         if (gateFailPark && !failedGate) {
             throw new Error(`task ${taskId} is parked on gate-fail but has no failed gate result on the newest park — refusing to infer one`);
@@ -98,8 +105,8 @@ export async function approve(argv, cwd = process.cwd()) {
             return disposition(cwd, runId, "fund-fixed-attempt", `upheld the reviewer for ${taskId} in ${runId} — by ${by}`, serialization.contended);
         }
         if (recheck) {
-            if (!gateFailPark || !failedGate) {
-                throw new Error(`--recheck applies to a gate-fail park; ${taskId}'s newest park is ${String(lastHuman?.data.kind ?? "none")} with failed gate ${failedGate ?? "none"} — refusing`);
+            if ((!gateFailPark || !failedGate) && !infraPark) {
+                throw new Error(`--recheck applies to a gate-fail or infra park; ${taskId}'s newest park is ${String(lastHuman?.data.kind ?? "none")} with failed gate ${failedGate ?? "none"} — refusing`);
             }
             journal.append("task-approved", taskId, {
                 by,
@@ -108,7 +115,7 @@ export async function approve(argv, cwd = process.cwd()) {
                 release: RECHECK_RELEASE,
                 ...(reviewRoundCeiling === undefined ? {} : { reviewRoundCeiling }),
             });
-            return disposition(cwd, runId, "re-dispatch", `re-checking ${taskId} in ${runId} — by ${by}; failed gate ${failedGate}; no gate marked satisfied`, serialization.contended);
+            return disposition(cwd, runId, "re-dispatch", `re-checking ${taskId} in ${runId} — by ${by}; ${failedGate ? `failed gate ${failedGate}` : "infra park"}; no gate marked satisfied`, serialization.contended);
         }
         if (waive) {
             if (!gateFailPark || !failedGate) {
@@ -153,12 +160,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 +173,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/beat.js

@@ -1,7 +1,7 @@
 import { mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { tickmarkrDir } from "../../graph/graph.js";
-import { SUPERVISION_BEAT_MS, SUPERVISION_DEFAULT_THRESHOLD_PCT, SUPERVISION_STALE_MS, SUPERVISION_TIERS, beatSupervision, supervisionStandDownPath, } from "../../run/supervision.js";
+import { SUPERVISION_BEAT_MS, SUPERVISION_DEFAULT_THRESHOLD_PCT, SUPERVISION_STALE_MS, SUPERVISION_TIERS, beatSupervision, resolveSupervisionRoot, supervisionStandDownPath, } from "../../run/supervision.js";
 // SUP-04: the writer side of supervision, as a VERB. `beatSupervision` and `SUPERVISION_BEAT_MS` shipped
 // with exactly one in-repo caller — the daemon, on one tier — so `status` printed
 // `orchestrator ARMED / overseer ABSENT / watch ABSENT` while a real overseer worked the run: two thirds
@@ -41,14 +41,17 @@ export async function beat(argv, cwd = process.cwd()) {
         throw new Error(`${named} needs --seat <identity> — a beat that names no seat arms a tier nobody occupies` +
             " (pass the seat's own pane id or agent name)");
     }
+    // A beat names repository state, never the caller's incidental directory. Resolution is read-only
+    // and happens before every write, so a non-repository invocation cannot create the state it claims.
+    const repoRoot = resolveSupervisionRoot(cwd);
     if (standDown)
-        return standDownTier(cwd, named, seat);
+        return standDownTier(repoRoot, named, seat);
     // Clear a stand-down marker left by an earlier session BEFORE beating: a valid marker outranks every
     // beat that does not strictly follow it, and two writes landing in the same millisecond do not. An
     // uncleared marker would render DISARMED while this verb claimed ARMED, so the removal is unguarded
     // too — `force` makes the ordinary "no marker" case a no-op, and anything else is a real failure.
-    rmSync(supervisionStandDownPath(cwd, named), { force: true, recursive: true });
-    beatSupervision(cwd, named, seat, pct === undefined ? undefined : { armId: armId ?? seat, pct, thresholdPct });
+    rmSync(supervisionStandDownPath(repoRoot, named), { force: true, recursive: true });
+    beatSupervision(repoRoot, named, seat, pct === undefined ? undefined : { armId: armId ?? seat, pct, thresholdPct });
     return `${named} ARMED as ${seat} — beat again every ${SUPERVISION_BEAT_MS / 1_000}s; the tier reads STALE ${SUPERVISION_STALE_MS / 1_000}s after the last beat`;
 }
 /** `--seat <identity>` or `--seat=<identity>`; blank and missing are the same answer — none. */

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

@@ -19,13 +19,17 @@ export type DoctorOpts = {
     compact?: boolean;
     /** Test seam for the same `orca status --json` transport production invokes. */
     orcaStatusProbe?: (cwd: string, binary: string) => Promise<ShResult>;
+    /** Test seam for Orca's authoritative per-agent hook coverage listing. */
+    orcaHooksStatusProbe?: (cwd: string, binary: string) => Promise<ShResult>;
+    /** Environment used only to explain whether auto-selection applies in this terminal. */
+    orcaEnv?: NodeJS.ProcessEnv | Record<string, string | undefined>;
     /** Test seam for shell-path discovery; absence remains a normal doctor row, never an exception. */
     resolveOrcaBinary?: (cwd: string) => string | undefined;
     /** Test seam for the runner-owned JSON listing used by the acceptance-oracle report row. */
     listTests?: (cwd: string) => Promise<VitestListResult>;
 };
 type OrcaCapability = {
-    verdict: "pass" | "fail";
+    verdict: "pass" | "fail" | "warn";
     detail: string;
 };
 /**
@@ -36,7 +40,7 @@ type OrcaCapability = {
  * Capability-row `detail` stays hermetic — never `OrcaError.message`, which embeds volatile CLI
  * stderr (Electron timestamps), so the row is byte-stable across runs.
  */
-export declare function probeOrcaCapability(cwd: string, opts?: Pick<DoctorOpts, "orcaStatusProbe" | "resolveOrcaBinary">): Promise<OrcaCapability>;
+export declare function probeOrcaCapability(cwd: string, opts?: Pick<DoctorOpts, "orcaStatusProbe" | "orcaHooksStatusProbe" | "resolveOrcaBinary" | "orcaEnv">): Promise<OrcaCapability>;
 export declare function runnerIgnoreFinding(cwd: string): {
     verdict: "pass" | "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";
@@ -25,6 +25,62 @@ export const LIVEBENCH_TABLE_MAX_AGE_DAYS = 90;
 const visual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
 const alignedStatusRow = (verdict, key, value) => `  ${statusRow(verdict, kvRow(key, value).slice(2))}`;
 const attentionRow = (text) => `  ${statusRow("warn", text)}`;
+const ORCA_HOOK_ADAPTERS = {
+    claude: "claude-code",
+    "claude-code": "claude-code",
+    codex: "codex",
+    cursor: "cursor-agent",
+    "cursor-agent": "cursor-agent",
+    grok: "grok",
+    kimi: "kimi",
+    opencode: "opencode",
+    pi: "pi",
+};
+function orcaSelectionDetail(env) {
+    const inside = env.TERM_PROGRAM === "Orca" && !!env.ORCA_TERMINAL_HANDLE?.trim();
+    return inside
+        ? "auto picks orca in this Orca terminal"
+        : "not an Orca terminal; auto picks orca only inside one; use --driver orca";
+}
+async function orcaHookCoverage(cwd, binary, opts) {
+    // A supplied status transport is a hermetic boundary: do not escape it to a real binary for the
+    // second command. Tests (and embedders) that want coverage supply the matching hook transport.
+    if (opts.orcaHooksStatusProbe === undefined && opts.orcaStatusProbe !== undefined) {
+        return "hooks status unavailable";
+    }
+    let response;
+    try {
+        response = await (opts.orcaHooksStatusProbe ?? ((probeCwd, executable) => sh(`${shq(executable)} agent hooks status --json`, probeCwd, 10_000)))(cwd, binary);
+        if (response.code !== 0 || response.timedOut)
+            return "hooks status unavailable";
+        // Until the driver's response-family expansion lands, this still uses its one strict envelope
+        // parser. Coverage comes only from this command's `statuses[].state`; managedHooksPresent and
+        // local agent config files are deliberately not alternative oracles.
+        const envelope = parseEnvelope("status", response.stdout);
+        const statuses = envelope.result.statuses;
+        if (!Array.isArray(statuses))
+            return "hooks status unavailable";
+        const coverage = new Map();
+        for (const raw of statuses) {
+            if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+                continue;
+            const row = raw;
+            const adapter = typeof row.agent === "string" ? ORCA_HOOK_ADAPTERS[row.agent] : undefined;
+            if (!adapter)
+                continue;
+            if (row.state === "installed")
+                coverage.set(adapter, "hooked");
+            else if (row.state === "not_installed")
+                coverage.set(adapter, "unhooked");
+        }
+        return coverage.size
+            ? `hooks: ${[...coverage].map(([adapter, state]) => `${adapter} ${state}`).join(", ")}`
+            : "hooks: no tickmarkr adapter status reported";
+    }
+    catch {
+        return "hooks status unavailable";
+    }
+}
 /**
  * Orca's status body is deliberately interpreted by T1's one shared envelope parser. Doctor owns
  * only capability presentation: it may classify an absent executable, but it never invents a second
@@ -34,7 +90,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 +118,18 @@ 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 hooks = await orcaHookCoverage(cwd, binary, opts);
+            const selection = orcaSelectionDetail(opts.orcaEnv ?? process.env);
+            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}); ${hooks} — ${selection}` };
+            }
+            const detail = `runtime reachable (${envelope.runtimeId}, appVersion ${appVersion}; fixture pin ${ORCA_FIXTURE_VERSION}); ${hooks} — ${selection}`;
+            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" };
@@ -449,8 +517,8 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     }
     if (trustNa.length)
         rows.push(`  ${dim("=")} ${dim(`n/a (${trustNa.length}): ${trustNa.join(", ")}`)}`);
-    // Orca is an explicit choice, so its health is capability information rather than an auto-routing
-    // input. A failed probe never changes pickDriver's auto ordering or substitutes subprocess.
+    // Capability is diagnostic only: auto-selection is decided from terminal identity markers, never
+    // from this runtime probe, and a failed probe cannot silently substitute another driver.
     const orca = await probeOrcaCapability(cwd, opts);
     rows.push(legend("execution runtime:"));
     rows.push(alignedStatusRow(orca.verdict, "orca", orca.detail));
@@ -567,9 +635,11 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
             const probed = probedMs !== undefined ? dim(` ${(probedMs / 1000).toFixed(1)}s`) : "";
             const auth = !v
                 ? dim("unknown")
-                : v.authed
-                    ? `${ok("authed")}${probed}`
-                    : `${fail("unauthed:")} ${trunc(v.reason ?? "probe failed", 40)} (${dateOf(v.probedAt)})`;
+                : v.probeError
+                    ? `${fail(`probe error (${v.probeError})`)}${probed}`
+                    : v.authed
+                        ? `${ok("authed")}${probed}`
+                        : `${fail("unauthed:")} ${trunc(v.reason ?? "probe failed", 40)} (${dateOf(v.probedAt)})`;
             const d = disallowedBy({ adapter: a.id, model: m }, cfg.routing);
             const denied = d?.by === "deny" ? d.entry : "—";
             const pref = preferRanks({ adapter: a.id, model: m }, cfg).map((p) => `${p.shape}#${p.rank}`).join(",") || "—";