tickmarkr 2.2.1 → 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/types.d.ts

@@ -116,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;
@@ -124,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

@@ -129,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.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",
 };
@@ -85,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`);
@@ -104,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,
@@ -114,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) {

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,6 +19,10 @@ 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. */
@@ -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

@@ -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
@@ -63,13 +119,15 @@ export async function probeOrcaCapability(cwd, opts = {}) {
             ? runtime.reachable
             : undefined;
         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})` };
+                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})`;
+            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)
@@ -459,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));
@@ -577,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(",") || "—";

package/dist/cli/commands/init.js

@@ -1,5 +1,6 @@
+import { execFileSync } from "node:child_process";
 import { appendFileSync, cpSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
@@ -8,20 +9,20 @@ import { configTemplate, DEFAULT_CONFIG, globalConfigDir, loadConfig } from "../
 import { LEGACY_PREFIX, specTemplate } from "../../compile/native.js";
 import { BANNER, kvRow, legend, rule, statusRow, title } from "../../brand.js";
 import { tickmarkrDir } from "../../graph/graph.js";
+import { orcaHostDetected } from "../../drivers/index.js";
 import { Journal } from "../../run/journal.js";
 import { doctor } from "./doctor.js";
 import { assembleFleetEditor } from "./fleet.js";
 const SCAFFOLD_SPEC = "tickmarkr.spec.md";
 // Operator-approved (2026-07-17) environments footer — no npm install for herdr (npm package
-// "herdr" is a reserved 0.0.0 placeholder as of that date). The orca row joins it with the v2.1
-// driver: it is a THIRD execution surface an operator selects outright — `auto` still resolves
-// herdr-else-subprocess and never picks it, so the footer names it beside the other two choices.
+// "herdr" is a reserved 0.0.0 placeholder as of that date). Auto resolves herdr → orca →
+// subprocess; the orca leg is environment-only, using the two markers Orca stamps in its terminals.
 const ENVIRONMENTS_FOOTER = [
     "environments:",
-    "  herdr — the full cockpit — every worker, judge, and consult is a visible pane you can watch and unblock · https://herdr.dev",
-    "  orca — visible terminals in the Orca app — an explicit driver choice: set driver: orca (auto never picks it) · https://onorca.dev",
+    "  herdr — the full cockpit — every worker, judge, and consult is a visible pane you can watch and unblock · https://herdr.dev · auto picks it first when HERDR_ENV=1",
+    "  orca — visible terminals in the Orca app — auto picks it inside an Orca terminal after herdr and before subprocess; set driver: orca to force it · https://onorca.dev",
     "  claude code — tickmarkr init --agent installs the /tkr skills + AGENTS.md so Claude Code (or any agent CLI) drives the loop natively",
-    "  anywhere — no herdr? same fail-closed gates, headless subprocess driver",
+    "  anywhere — no herdr or Orca terminal? same fail-closed gates, headless subprocess driver (legacy: no herdr? same fail-closed gates, headless subprocess driver when Orca markers are absent)",
 ].join("\n");
 /** Latest journal without a run-end event, if any. */
 function activeRunId(cwd) {
@@ -140,17 +141,6 @@ you were handed the whole picture — list the repository root, open every guida
   direction each moves, what makes a criterion real, and why an absence or a source-text grep is never a
   criterion. Read it before authoring or repairing acceptance items.
 - **Editing \`src/gates/\`, \`src/compile/\` or \`src/graph/\`?** Read \`docs/codebase/ARCHITECTURE.md\` first.
-- **EVERY fix gets a ship/no-ship decision, recorded, at the moment it is made.** Ask one question of each
-  one: *does a user hit this defect?* If yes, the fix belongs in \`src/**\` or \`skills/**\` — the only trees
-  the package carries (\`files: [dist, schema, skills, fixtures]\`). A script, overlay, config entry or
-  operator-side workaround that resolves the symptom **locally is not the fix; it is a decision to leave
-  every other user broken**, and it must say so in writing and name the condition that removes it.
-  **The default answer is SHIP.** A local remedy is the exception and carries the burden of proof.
-  Watch for the three shapes this hides in: a fix applied where you happened to be standing rather than
-  where the defect lives; an observation filed with a product fix named in its own text and queued
-  nowhere; and a local tool that quietly grows into a product feature nobody shipped. **A defect and its
-  fix must be recorded in the same place, or the queue silently becomes a list of things everyone assumed
-  someone else had shipped.**
 ${DOCS_END}
 `;
 // Every applicable host location gets the skills, each paired with its own repository guidance
@@ -229,7 +219,28 @@ const describeDrift = (d) => [
 // should not be asked again just because a copy drifted. Staleness is a different question with a
 // different answer (`--agent --force`), and it is reported by name on every init path below.
 const skillsInstalled = (cwd) => hostTargets(cwd).every((t) => AGENT_SKILLS.every((s) => existsSync(join(t.skillsDir, s, "SKILL.md"))));
-const wizardDriverDefault = () => process.env.HERDR_ENV === "1" ? "herdr" : "auto";
+const wizardDriverDefault = () => process.env.HERDR_ENV === "1" ? "herdr" : orcaHostDetected() ? "orca" : "auto";
+function packageName(cwd) {
+    try {
+        const parsed = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8"));
+        return typeof parsed.name === "string" ? parsed.name : null;
+    }
+    catch {
+        return null;
+    }
+}
+function gitTracked(cwd, path) {
+    const rel = relative(cwd, path);
+    if (rel.startsWith(".."))
+        return false;
+    try {
+        execFileSync("git", ["ls-files", "--error-unmatch", "--", rel], { cwd, stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 async function installAgentFiles(cwd, force, docs, notes) {
     const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true;
     let prompt;
@@ -257,13 +268,14 @@ async function installAgentFiles(cwd, force, docs, notes) {
                     notes.push(`kept current ${dest}`);
                     continue;
                 }
+                const tracked = exists && gitTracked(cwd, dest);
                 if (exists && !force && !(await confirm(`Overwrite ${dest} (${describeDrift(stale)})?`))) {
-                    notes.push(`skipped existing ${dest} — ${describeDrift(stale)}; pass --force to overwrite it`);
+                    notes.push(`skipped existing ${tracked ? "tracked " : ""}${dest} — ${describeDrift(stale)}; pass --force to overwrite it`);
                     continue;
                 }
                 // whole skill dir, not just SKILL.md — the overseer ships its pane-watcher script
                 cpSync(fileURLToPath(new URL(`../../../skills/${skill}`, import.meta.url)), join(skillsDir, skill), { recursive: true });
-                notes.push(`${exists ? "overwrote" : "wrote"} ${dest}`);
+                notes.push(`${exists ? "overwrote" : "wrote"} ${tracked ? "tracked " : ""}${dest}`);
             }
             const current = existsSync(docPath) ? readFileSync(docPath, "utf8") : "";
             // The block is CANONICAL guidance ("stated once here, restated nowhere"), so a repo that has
@@ -341,6 +353,9 @@ export async function init(argv, cwd = process.cwd(), io = {}) {
     });
     // banner at START on the visual surface — every init path, not just the wizard, and never trailing the probe (operator report 2026-07-17)
     emitBanner();
+    if (packageName(cwd) === "tickmarkr") {
+        throw new Error("OBS-584: tickmarkr init refuses to run inside the tickmarkr source repository");
+    }
     const gdir = values["global-dir"] ?? globalConfigDir();
     mkdirSync(gdir, { recursive: true });
     const notes = [];

package/dist/cli/commands/plan.js

@@ -1,7 +1,9 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
 import { allAdapters, discoverChannels, doctorAgeMs, modelAuthExclusions, probeAll, readDoctor, servableExclusions, servabilityLine } from "../../adapters/registry.js";
 import { formatModelAuthLine, contextWindowLints, modelLints, preferEntryLints, ttyVisual } from "../../adapters/model-lints.js";
 import { GLYPHS, dim, rule, title, warn } from "../../brand.js";
-import { parseArgs } from "node:util";
 import { collateralLints, sourceScopeLints } from "../../compile/collateral.js";
 import { classifyContextPath } from "../../compile/native.js";
 import { DEFAULT_CONFIG, overlayPreferShapes, ROUTING_MODES, TIER_RANK } from "../../config/config.js";
@@ -106,10 +108,15 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
     }
     const g = loadGraph(cwd);
     const oracleRefusals = new Map();
+    const oracleAdvisories = new Map();
     if (g.tasks.some((task) => task.acceptance.some((item) => typeof item === "object" && item.oracle === "test"))) {
         const listing = await (opts.listTests ?? listVitestTests)(cwd);
         for (const task of g.tasks) {
             const refusals = [];
+            const advisories = [];
+            const authoredTest = task.files
+                .map((path) => path.replace(/^\.\//, ""))
+                .find((path) => /^tests\/.+\.test\.ts$/.test(path) && !/[?*{[]/.test(path) && !existsSync(join(cwd, path)));
             if (listing.status === "failed") {
                 if (task.acceptance.some((item) => typeof item === "object" && item.oracle === "test")) {
                     refusals.push(`acceptance oracle unresolved — runner listing failed: ${listing.error.split("\n")[0]}`);
@@ -117,7 +124,10 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
             }
             else {
                 for (const audit of auditNamedTestOracles(task.acceptance, listing.tests)) {
-                    if (audit.matches.length === 0) {
+                    if (audit.matches.length === 0 && authoredTest) {
+                        advisories.push(`acceptance oracle ${JSON.stringify(audit.criterion)} not yet written (worker authors ${authoredTest})`);
+                    }
+                    else if (audit.matches.length === 0) {
                         refusals.push(`acceptance oracle ${JSON.stringify(audit.criterion)} matches zero runner-listed test names`);
                     }
                     else if (audit.matches.length > 1) {
@@ -127,6 +137,8 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
             }
             if (refusals.length)
                 oracleRefusals.set(task.id, refusals);
+            if (advisories.length)
+                oracleAdvisories.set(task.id, advisories);
         }
     }
     const inputFindings = await taskInputFindings(g.tasks, cwd);
@@ -283,6 +295,8 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
                 lines.push(d);
             lints.push(`${t.id}: unroutable — ${msg}`);
         }
+        for (const advisory of oracleAdvisories.get(t.id) ?? [])
+            lines.push(`    ! ${advisory}`);
     }
     const inputWarnings = inputFindings.filter((finding) => finding.severity === "warn");
     if (inputWarnings.length) {

package/dist/cli/commands/report.js

@@ -4,6 +4,7 @@ import { ttyVisual } from "../../adapters/model-lints.js";
 import { addUsage } from "../../adapters/types.js";
 import { dim, rule, title } from "../../brand.js";
 import { loadConfig } from "../../config/config.js";
+import { modelProvider } from "../../gates/review.js";
 import { buildProofBundle, gateDeclined } from "../../report/bundle.js";
 import { compareRuns } from "../../report/compare.js";
 import { estimateCosts } from "../../report/cost.js";
@@ -35,6 +36,22 @@ const channelLabel = (data) => {
     const { adapter, model } = a;
     return typeof adapter === "string" && typeof model === "string" ? `${adapter}:${model}` : EM;
 };
+const modelFromChannel = (channel) => channel.slice(channel.indexOf(":") + 1);
+const reviewerIdentity = (data) => {
+    const details = typeof data.details === "string" ? data.details : "";
+    const fromDetails = /reviewer\s+([^\s;()]+:[^\s;()]+)/i.exec(details)?.[1];
+    const reviewer = typeof data.reviewer === "string" ? data.reviewer : fromDetails;
+    if (!reviewer || !reviewer.includes(":"))
+        return undefined;
+    const vendor = typeof data.vendor === "string"
+        ? data.vendor
+        : /vendor:\s*([^;()]+)/i.exec(details)?.[1]?.trim()
+            ?? /\(([^;:()]+)\):/.exec(details)?.[1]?.trim();
+    const provider = typeof data.provider === "string"
+        ? data.provider
+        : modelProvider(modelFromChannel(reviewer), vendor ?? "unknown");
+    return { reviewer, provider, ...(vendor ? { vendor } : {}) };
+};
 const rateBasis = (row) => {
     if (!row.rate)
         return EM;
@@ -245,6 +262,7 @@ export function renderMarkdownRecord(runId, events, prices = [], rows = []) {
         const dispatches = events.filter((e) => e.taskId === taskId && e.event === "task-dispatch");
         const channels = dispatches.map((e) => channelLabel(e.data));
         const gates = events.filter((e) => e.taskId === taskId && e.event === "gate-result");
+        const leg2 = events.filter((e) => e.taskId === taskId && e.event === "review-leg2");
         const consults = events.filter((e) => e.taskId === taskId && e.event === "consult-verdict");
         const deviations = events.filter((e) => e.taskId === taskId && e.event === "route-deviation");
         const merge = [...events].reverse().find((e) => e.taskId === taskId && e.event === "merge");
@@ -267,10 +285,28 @@ export function renderMarkdownRecord(runId, events, prices = [], rows = []) {
         if (gates.length) {
             for (const g of gates) {
                 // T11: a declined gate never ran — report it as declined, never as a pass.
-                const pass = gateDeclined(g.data) ? "declined" : g.data.pass === true ? "pass" : g.data.pass === false ? "fail" : EM;
+                let pass = gateDeclined(g.data) ? "declined" : g.data.pass === true ? "pass" : g.data.pass === false ? "fail" : EM;
                 const gate = typeof g.data.gate === "string" ? g.data.gate : EM;
+                if (gate === "review" && pass === "pass") {
+                    const reviewer = reviewerIdentity(g.data);
+                    const before = events.slice(0, events.indexOf(g) + 1).reverse()
+                        .find((e) => e.taskId === taskId && e.event === "task-dispatch");
+                    const author = channelLabel(before?.data ?? {});
+                    const authorProvider = author === EM ? "unknown" : modelProvider(modelFromChannel(author));
+                    if (reviewer && authorProvider !== "unknown" && authorProvider === reviewer.provider) {
+                        pass = "pass (same-provider — independence not established)";
+                    }
+                }
                 lines.push(`  - ${gate}: ${pass} — ${firstLine(g.data.details)}`);
             }
+            for (const row of leg2) {
+                const pass = row.data.pass === true ? "pass" : row.data.pass === false ? "fail" : EM;
+                const identity = reviewerIdentity(row.data);
+                const identityText = identity
+                    ? `reviewer ${identity.reviewer}${identity.vendor ? ` (vendor: ${identity.vendor}; provider: ${identity.provider})` : ` (provider: ${identity.provider})`}`
+                    : firstLine(row.data.details);
+                lines.push(`  - review-leg2: ${pass} (supersedes daemon review) — ${identityText}`);
+            }
         }
         else
             lines.push(`  - ${EM}`);

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

@@ -4,6 +4,11 @@ export declare function parseCriteria(text: string): AcceptanceItem[];
 export declare const HUMAN_CHANNEL: BillingChannel;
 export declare const HUMAN_AUTHOR: Assignment;
 export declare function verifyStateDir(cwd: string): string;
+/** Linked worktrees share operational state with the repository that owns the common git dir. */
+export declare function verifyStateRoot(cwd: string): Promise<string>;
+/** Cache identity is repository content, never a checkout path. */
+export declare function baselineCachePath(cwd: string, baseSha: string, commands: Record<string, string>): string;
+export declare function excludeAuthorProvider(channels: BillingChannel[], author: BillingChannel): BillingChannel[];
 export declare function verify(argv: string[], cwd?: string): Promise<{
     out: string;
     code: number;