tickmarkr 2.2.0 → 2.3.0

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:
@@ -804,9 +805,9 @@ acceptance is required on every task (a nested list of observable outcomes).
       set closed — this milestone paid a halted run to learn that the two populations are not identical.
     - SPIKE-THE-CONTRACT-THEN-SCOPE trigger question: COULD A TEST THIS TASK DOES NOT OWN BE ASSERTING THE
       THING I AM CHANGING? "I'D HAVE TO GREP TO KNOW" IS YES. This applies to observable contracts:
-      execution order, event-stream order, diagnostics/output sets, CLI surface, serialised formats, or
-      timing measurements. If yes, implement the change as a throwaway spike, run the full suite, read the
-      reds, THEN scope files[].
+      execution order, event-stream order, diagnostics/output sets, CLI surface, serialised formats,
+      timing measurements, or adding or removing a shipped file. If yes, implement the change as a
+      throwaway spike, run the full suite, read the reds, THEN scope files[].
     - Caveat: a spike measures ONE implementation. It converts unknown collateral into
       measured-for-one-specimen collateral; it does NOT make its reds the closed blocker set for every
       route. A worker taking a different route can still red on unowned collateral; that remains a PLAN
@@ -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/config/config.js

@@ -713,7 +713,7 @@ export function overlayBytesLoadError(repoRoot, bytes, opts = {}) {
 export function configTemplate(overlay) {
     const base = `# tickmarkr config overlay — merges over built-in defaults (repo beats global beats defaults)
 # concurrency: 3
-# driver: auto            # auto | herdr | subprocess | orca
+# driver: auto            # auto: herdr when HERDR_ENV=1, then orca when TERM_PROGRAM=Orca + ORCA_TERMINAL_HANDLE, else subprocess; name orca explicitly outside an Orca terminal
 # taskTimeoutMinutes: 30
 # contextWarnTokens: 170000   # v1.23: journal+notify once per attempt when live worker context crosses this (status shows the sample)
 # setup: npm ci --prefer-offline   # run in each fresh task worktree before dispatch

package/dist/drivers/index.d.ts

@@ -2,6 +2,13 @@ import type { TickmarkrConfig } from "../config/config.js";
 import type { ExecutorDriver } from "./types.js";
 export declare const DRIVER_CHOICES: readonly ["auto", "herdr", "subprocess", "orca"];
 export type DriverChoice = (typeof DRIVER_CHOICES)[number];
+/**
+ * Orca authors both markers on every terminal it creates. Requiring the pair avoids treating an
+ * unrelated TERM_PROGRAM value or a copied terminal handle as host identity. This is deliberately
+ * environment-only: selection must not execute a binary or contact the Orca runtime.
+ */
+export declare function orcaHostDetected(env?: NodeJS.ProcessEnv): boolean;
 /** 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,15 @@ 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();
+/**
+ * Orca authors both markers on every terminal it creates. Requiring the pair avoids treating an
+ * unrelated TERM_PROGRAM value or a copied terminal handle as host identity. This is deliberately
+ * environment-only: selection must not execute a binary or contact the Orca runtime.
+ */
+export function orcaHostDetected(env = process.env) {
+    return env.TERM_PROGRAM === "Orca" && env.ORCA_TERMINAL_HANDLE !== undefined;
+}
 /** 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 +20,39 @@ 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 (herdrAvailable && driver.id === "herdr")
+        return "auto → herdr (HERDR_ENV=1)";
+    if (!herdrAvailable && orcaHostDetected() && driver.id === "orca") {
+        return "auto → orca (TERM_PROGRAM+ORCA_TERMINAL_HANDLE)";
+    }
+    if (!herdrAvailable && !orcaHostDetected() && driver.id === "subprocess") {
+        return "auto → subprocess (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 an explicit or detected choice.
+            : want === "orca" ? new OrcaDriver()
+                : HerdrDriver.available() ? new HerdrDriver("herdr", cfg.visibility.workersPerTab)
+                    : orcaHostDetected() ? new OrcaDriver()
+                        : new SubprocessDriver();
+    if (selectedOverride !== undefined)
+        overrideByDriver.set(driver, selectedOverride);
+    return driver;
 }

package/dist/drivers/orca.d.ts

@@ -1,13 +1,20 @@
 import { type ShResult } from "../run/git.js";
+import { type JournalEvent } from "../run/journal.js";
 import { type ExecutorDriver, type NotifyOpts, type Slot, type SlotOpts } from "./types.js";
 /** 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 declare const ORCA_RESPONSE_FAMILIES: readonly ["status", "create", "list", "read", "send", "wait", "show", "close", "worktree-current", "hooks-status"];
 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";
 export declare const STATUS_GOVERNED_METHODS: readonly ["read", "waitOutput", "status", "waitAgentStatus"];
+export declare const WORKTREE_ADOPTION_TIMEOUT_MS = 60000;
 export interface OrcaExec {
     (args: string[], cwd: string, timeoutMs?: number): Promise<ShResult>;
 }
@@ -38,6 +45,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 +95,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;
@@ -94,6 +115,9 @@ export declare class OrcaDriver implements ExecutorDriver {
     private pageLines;
     private pollMs;
     private probeStalenessMs;
+    private journalRoots;
+    private narrate?;
+    private hookCoverage?;
     constructor(opts?: OrcaDriverOpts);
     private call;
     /** The live runtime's identity, or an explicit failure. A missing or unreachable runtime is a
@@ -109,6 +133,15 @@ export declare class OrcaDriver implements ExecutorDriver {
     private assertAvailable;
     run(slot: Slot, cmd: string): Promise<void>;
     private create;
+    /**
+     * A freshly-created git checkout does not become a valid Orca selector atomically. Ask
+     * `worktree current` FROM that checkout until Orca itself resolves the exact filesystem identity;
+     * an enclosing checkout is still not adoption. Only selector_not_found is a retryable refusal —
+     * malformed envelopes and every other refusal remain explicit driver failures.
+     */
+    private awaitWorktreeAdoption;
+    /** Same repo/run/narration path Herdr uses for its driver-owned dispatch-retry row. */
+    private appendAdoptionWait;
     /**
      * Every terminal-addressed call — read AND write — goes through here, and the runtime identity is
      * established BEFORE the runtime-scoped handle goes on the wire. Discarding a lookalike's answer
@@ -130,6 +163,8 @@ export declare class OrcaDriver implements ExecutorDriver {
     private liveShowTerm;
     private tailText;
     private readPage;
+    /** A rendered-frame liveness read. `--screen` and `--cursor` are mutually exclusive in Orca. */
+    private readScreen;
     /** A single UNPAGED tail read — exactly what the caller asked for and nothing more. Markers split
      *  across cursor pages are not reassembled here; that is waitOutput's job. */
     read(slot: Slot, lines: number): Promise<string>;
@@ -144,12 +179,17 @@ export declare class OrcaDriver implements ExecutorDriver {
         regex?: boolean;
     }): Promise<boolean>;
     status(slot: Slot): Promise<string>;
+    private hookAgent;
+    /** true = hooked, false = definitively unhooked, undefined = agent absent from Orca's table. */
+    private agentHookAvailable;
+    private loadHookCoverage;
     /** One `terminal wait` through the full identity machinery. The recorded 1.4.186 elapsed answer
      *  is rc 1 + ok:true + {handle, condition, satisfied:false, status:"running"}; it is "not yet"
      *  only after this method validates all four fields. Any malformed/refused wait remains explicit. */
     private waitCondition;
     waitAgentStatus(slot: Slot, status: string, timeoutMs: number): Promise<boolean>;
     notify(msg: string, opts?: NotifyOpts): Promise<void>;
+    narrateWith(narrate: (event: JournalEvent) => void): void;
     close(slot: Slot): Promise<void>;
     /**
      * The one destructive call in this driver, for a slot's own terminal AND for a reconcile candidate

package/dist/drivers/orca.js

@@ -2,13 +2,14 @@ import { realpathSync } from "node:fs";
 import { resolve } from "node:path";
 import { shq } from "../adapters/types.js";
 import { createWorktree, sh } from "../run/git.js";
+import { Journal } from "../run/journal.js";
 import { MAX_BUF } from "./subprocess.js";
-import { formatOwnedName, panesToClose } from "./types.js";
+import { formatOwnedName, panesToClose, parseOwnedName } from "./types.js";
 // Orca (onorca.dev) as a third execution surface beside herdr and subprocess. tickmarkr keeps
 // 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
@@ -31,8 +32,16 @@ import { formatOwnedName, panesToClose } from "./types.js";
 //  - `terminal list`'s `--worktree` is OPTIONAL (same help): the reconcile sweep omits it, because
 //    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_RESPONSE_FAMILIES = [
+    "status", "create", "list", "read", "send", "wait", "show", "close",
+    "worktree-current", "hooks-status",
+];
+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";
@@ -45,6 +54,9 @@ const PAGE_LINES = 500; // per-page ask; orca caps server-side and reports `limi
 const LIST_LIMIT = 10000; // well past orca's own row default; `truncated` still decides (listAll)
 const MAX_PAGES = 400; // runaway guard: a cursor that stops advancing ends the sweep, never loops
 const POLL_MS = 200;
+export const WORKTREE_ADOPTION_TIMEOUT_MS = 60_000;
+const WORKTREE_ADOPTION_POLL_MS = 1_000;
+const WORKTREE_ADOPTION_JOURNAL_MS = 2_000;
 const SYSTEM_TIME = {
     now: () => Date.now(),
     sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
@@ -79,6 +91,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
@@ -234,8 +259,11 @@ export class OrcaDriver {
     pageLines;
     pollMs;
     probeStalenessMs;
+    journalRoots = new Map();
+    narrate;
+    hookCoverage;
     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 +285,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 +306,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) {
@@ -315,7 +357,7 @@ export class OrcaDriver {
         // Canonical: git and Orca can spell one checkout two ways, and every later comparison — create
         // receipt, relist, reconcile — is against THIS value.
         const worktree = canonicalWorktreePath(cwd);
-        this.slots.set(id, { title, cwd: worktree, buf: "", recoveries: 0, recovering: false });
+        this.slots.set(id, { title, cwd: worktree, agent: opts?.agent, buf: "", recoveries: 0, recovering: false });
         return { id, name: title, cwd: worktree, group: opts?.group };
     }
     /** Where to invoke the CLI for this slot's calls (see OrcaSlotState.dir). */
@@ -364,6 +406,7 @@ export class OrcaDriver {
     }
     async create(st, cmd) {
         await this.probeRuntime(this.cliCwd(st));
+        await this.awaitWorktreeAdoption(st);
         // The selector names THIS slot's checkout outright, and the CLI child is bound to it too, so
         // neither the UI's active worktree (`active`/`current`) nor the daemon's cwd can place it.
         const env = await this.call("create", [
@@ -392,6 +435,68 @@ 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" });
+        }
+    }
+    /**
+     * A freshly-created git checkout does not become a valid Orca selector atomically. Ask
+     * `worktree current` FROM that checkout until Orca itself resolves the exact filesystem identity;
+     * an enclosing checkout is still not adoption. Only selector_not_found is a retryable refusal —
+     * malformed envelopes and every other refusal remain explicit driver failures.
+     */
+    async awaitWorktreeAdoption(st) {
+        const started = this.time.now();
+        const deadline = started + WORKTREE_ADOPTION_TIMEOUT_MS;
+        let lastReported;
+        for (;;) {
+            const left = deadline - this.time.now();
+            if (left < 0)
+                break;
+            try {
+                const env = await this.call("worktree-current", ["worktree", "current"], st.cwd, Math.max(1, left));
+                const worktree = env.result.worktree;
+                if (typeof worktree !== "object" || worktree === null || Array.isArray(worktree)) {
+                    throw new OrcaError("worktree-current", "response carries no worktree record", env.raw, { runtimeId: env.runtimeId });
+                }
+                const reported = terminalWorktree(worktree);
+                if (!reported) {
+                    throw new OrcaError("worktree-current", "worktree record carries no path", env.raw, { runtimeId: env.runtimeId });
+                }
+                lastReported = canonicalWorktreePath(reported);
+                if (lastReported === st.cwd) {
+                    const waitedMs = this.time.now() - started;
+                    if (waitedMs > WORKTREE_ADOPTION_JOURNAL_MS)
+                        this.appendAdoptionWait(st, waitedMs);
+                    return;
+                }
+            }
+            catch (error) {
+                if (!(error instanceof OrcaError) || error.code !== "selector_not_found")
+                    throw error;
+                lastReported = undefined;
+            }
+            const remaining = deadline - this.time.now();
+            if (remaining <= 0)
+                break;
+            await this.time.sleep(Math.min(WORKTREE_ADOPTION_POLL_MS, remaining));
+        }
+        const waitedMs = this.time.now() - started;
+        throw new OrcaUnavailableError("worktree-current", `Orca did not adopt ${st.cwd} within ${WORKTREE_ADOPTION_TIMEOUT_MS}ms${lastReported ? ` (last answered ${lastReported})` : ""}`, `waitedMs=${waitedMs}`);
+    }
+    /** Same repo/run/narration path Herdr uses for its driver-owned dispatch-retry row. */
+    appendAdoptionWait(st, waitedMs) {
+        const owned = parseOwnedName(st.title);
+        if (!owned)
+            throw new Error(`cannot journal worktree-adoption-wait: slot ${st.title} carries no run identity`);
+        const repoRoot = this.journalRoots.get(st.cwd);
+        if (!repoRoot) {
+            throw new Error(`cannot journal worktree-adoption-wait: slot ${st.title} has no daemon repo binding for ${st.cwd}`);
+        }
+        Journal.open(repoRoot, owned.runId, this.narrate).append("worktree-adoption-wait", owned.taskId, {
+            milliseconds: waitedMs,
+        });
     }
     // ---- handle identity and restart recovery ----------------------------------------------------
     /**
@@ -450,7 +555,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;
                         }
@@ -592,6 +697,18 @@ export class OrcaDriver {
         ], this.cliCwd(st)), { onRecovered: () => { recovered = true; } });
         return { term: this.validated(family, st, env), raw: env.raw, recovered };
     }
+    /** A rendered-frame liveness read. `--screen` and `--cursor` are mutually exclusive in Orca. */
+    async readScreen(st) {
+        const env = await this.terminalOp("status", st, (h) => this.call("read", [
+            "terminal", "read", "--terminal", h, "--screen",
+        ], this.cliCwd(st)));
+        const term = this.validated("status", st, env);
+        const source = str(term.source);
+        if (source !== "screen" && source !== "screen-unavailable") {
+            throw new OrcaError("read", `screen read reports source ${source ?? "absent"}, not screen or screen-unavailable`, env.raw);
+        }
+        return { term, source };
+    }
     /** A single UNPAGED tail read — exactly what the caller asked for and nothing more. Markers split
      *  across cursor pages are not reassembled here; that is waitOutput's job. */
     async read(slot, lines) {
@@ -668,10 +785,14 @@ export class OrcaDriver {
             // reporting even when the show record alone would still look connected (show carries no
             // status field of its own, so a terminal can report "unknown"/"exited" on read while its
             // show row still says connected — the read leg is the only place that catches that).
-            await this.readPage("status", st, undefined, 1);
+            const screen = await this.readScreen(st);
             if (`${st.runtimeId}:${st.handle}:${st.recoveries}` !== gen) {
                 continue;
             }
+            // No rendered frame means no trustworthy TUI state. In particular, the stream fragments this
+            // call replaced cannot license an idle verdict or a wait probe.
+            if (screen.source === "screen-unavailable")
+                return "unknown";
             const env = await this.terminalOp("show", st, (h) => this.call("show", ["terminal", "show", "--terminal", h], this.cliCwd(st)));
             if (`${st.runtimeId}:${st.handle}:${st.recoveries}` !== gen) {
                 continue;
@@ -679,6 +800,11 @@ export class OrcaDriver {
             const term = this.liveShowTerm("status", st, env);
             if (term.agentWait === true)
                 return "blocked";
+            // Orca can only report tui-idle/agentWait for agents whose managed hook is installed. A
+            // definitively unhooked adapter is unknown; an agent absent from Orca's table keeps the
+            // legacy probe because absence is not proof that the CLI has no compatible status surface.
+            if (await this.agentHookAvailable(st) === false)
+                return "unknown";
             // `idle` is proven only by orca's own tui-idle condition: a 1ms wait is a point-in-time probe —
             // satisfied now → idle; elapsed (the recorded `timeout` refusal) → not idle.
             const isIdle = await this.waitCondition(st, "tui-idle", 1);
@@ -688,6 +814,50 @@ export class OrcaDriver {
             return mapAgentState(term, isIdle);
         }
     }
+    hookAgent(adapter) {
+        if (adapter === "claude-code")
+            return "claude";
+        if (adapter === "cursor-agent")
+            return "cursor";
+        return adapter;
+    }
+    /** true = hooked, false = definitively unhooked, undefined = agent absent from Orca's table. */
+    async agentHookAvailable(st) {
+        if (!st.agent)
+            return undefined;
+        this.hookCoverage ??= this.loadHookCoverage(st.cwd);
+        const coverage = await this.hookCoverage;
+        const state = coverage.states.get(this.hookAgent(st.agent));
+        // The table's omission is deliberately inconclusive even when managed hooks are disabled:
+        // Orca may not know this agent, so preserve the legacy probe exactly as an unlisted row does.
+        if (state === undefined)
+            return undefined;
+        return coverage.enabled && state === "installed";
+    }
+    async loadHookCoverage(cwd) {
+        const env = await this.call("hooks-status", ["agent", "hooks", "status"], cwd);
+        if (typeof env.result.enabled !== "boolean") {
+            throw new OrcaError("hooks-status", "response carries no boolean enabled", env.raw, { runtimeId: env.runtimeId });
+        }
+        const statuses = env.result.statuses;
+        if (!Array.isArray(statuses)) {
+            throw new OrcaError("hooks-status", "response carries no statuses array", env.raw, { runtimeId: env.runtimeId });
+        }
+        const states = new Map();
+        const allowed = new Set(["installed", "not_installed", "partial", "error"]);
+        for (const row of statuses) {
+            if (typeof row !== "object" || row === null || Array.isArray(row)) {
+                throw new OrcaError("hooks-status", "statuses carries a non-object row", env.raw, { runtimeId: env.runtimeId });
+            }
+            const agent = str(row.agent);
+            const state = str(row.state);
+            if (!agent || !state || !allowed.has(state)) {
+                throw new OrcaError("hooks-status", "status row carries no valid agent/state pair", env.raw, { runtimeId: env.runtimeId });
+            }
+            states.set(agent, state);
+        }
+        return { enabled: env.result.enabled, states };
+    }
     /** One `terminal wait` through the full identity machinery. The recorded 1.4.186 elapsed answer
      *  is rc 1 + ok:true + {handle, condition, satisfied:false, status:"running"}; it is "not yet"
      *  only after this method validates all four fields. Any malformed/refused wait remains explicit. */
@@ -755,6 +925,9 @@ export class OrcaDriver {
             return;
         console.log(`[tickmarkr] ${msg}`); // console fallback only — notification injection is out of scope
     }
+    narrateWith(narrate) {
+        this.narrate = narrate;
+    }
     async close(slot) {
         const st = this.slots.get(slot.id);
         if (!st)
@@ -873,7 +1046,11 @@ export class OrcaDriver {
         catch { /* cosmetic — visibility hygiene never fails the run */ }
     }
     // tickmarkr's own createWorktree stays the sole checkout authority — orca never makes worktrees.
-    worktree(repo, branch, baseRef) {
-        return createWorktree(repo, branch, baseRef);
+    async worktree(repo, branch, baseRef) {
+        const worktree = await createWorktree(repo, branch, baseRef);
+        const repoRoot = canonicalWorktreePath(repo);
+        this.journalRoots.set(repoRoot, repoRoot);
+        this.journalRoots.set(canonicalWorktreePath(worktree), repoRoot);
+        return worktree;
     }
 }

package/dist/drivers/subprocess.d.ts

@@ -1,14 +1,14 @@
 import type { ExecutorDriver, NotifyOpts, Slot } from "./types.js";
 export declare const MAX_BUF: number;
-export declare const HERDR_CONTROL_VARS: readonly ["HERDR_ENV", "HERDR_SOCKET_PATH"];
+export declare const HERDR_CONTROL_VARS: readonly ["HERDR_ENV", "HERDR_SOCKET_PATH", "ORCA_TERMINAL_HANDLE", "ORCA_PANE_KEY", "ORCA_TAB_ID"];
 /**
- * Copy of worker env with the fork cap applied and herdr control-plane vars stripped.
+ * Copy of worker env with the fork cap applied and host control-plane vars stripped.
  * The cap is the one the enclosing run resolved (resolvedForkCap) — a worker's suites divide the
  * same machine the gate shells do, so both seams have to read the same run-owned number rather
  * than a flat constant. The operator's own export still wins.
  */
 export declare function sealHerdrEnv(env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
-/** Pane/login-shell form of the same worker env seal (herdr seed + daemon setup). */
+/** Pane/login-shell form of the same host-neutral worker env seal (herdr seed + daemon setup). */
 export declare function herdrSealShellPrefix(env?: NodeJS.ProcessEnv): string;
 export declare class SubprocessDriver implements ExecutorDriver {
     id: string;

package/dist/drivers/subprocess.js

@@ -8,13 +8,20 @@ import { createWorktree, FORK_CAP_ENV, resolvedForkCap } from "../run/git.js";
 // waitOutput poll (~10MB/s sustained, far beyond agent-CLI rates). Tail-truncate, never head:
 // consumers only ever tail-read.
 export const MAX_BUF = 2 * 1024 * 1024;
-// OBS-17 / v1.22 T3: control-plane vars that let a process talk to the operator's herdr.
-// Workers, judges, reviewers, and consults must never inherit them — only the daemon process
-// (and its own herdr driver CLI calls) keep the live session. Socket path is the wire; HERDR_ENV
-// is the "I am inside herdr" gate every agent skill checks before mutating panes.
-export const HERDR_CONTROL_VARS = ["HERDR_ENV", "HERDR_SOCKET_PATH"];
+// OBS-17 / v1.22 T3 and OBS-843: host control-plane vars that let a process address the operator's
+// herdr or Orca UI. Workers, judges, reviewers, and consults must never inherit them — only the
+// daemon process and its driver calls keep the live session. TERM_PROGRAM is host description, not
+// an addressing capability, and ORCA_AGENT_HOOK_* belongs to agent status transport, so both stay.
+// Keep the exported name for compatibility even though the list is now host-neutral.
+export const HERDR_CONTROL_VARS = [
+    "HERDR_ENV",
+    "HERDR_SOCKET_PATH",
+    "ORCA_TERMINAL_HANDLE",
+    "ORCA_PANE_KEY",
+    "ORCA_TAB_ID",
+];
 /**
- * Copy of worker env with the fork cap applied and herdr control-plane vars stripped.
+ * Copy of worker env with the fork cap applied and host control-plane vars stripped.
  * The cap is the one the enclosing run resolved (resolvedForkCap) — a worker's suites divide the
  * same machine the gate shells do, so both seams have to read the same run-owned number rather
  * than a flat constant. The operator's own export still wins.
@@ -27,7 +34,7 @@ export function sealHerdrEnv(env = process.env) {
         delete out[k];
     return out;
 }
-/** Pane/login-shell form of the same worker env seal (herdr seed + daemon setup). */
+/** Pane/login-shell form of the same host-neutral worker env seal (herdr seed + daemon setup). */
 export function herdrSealShellPrefix(env = process.env) {
     const forkCap = sealHerdrEnv(env)[FORK_CAP_ENV] ?? resolvedForkCap();
     return `export ${FORK_CAP_ENV}=${shq(forkCap)}; ` +
@@ -56,8 +63,8 @@ export class SubprocessDriver {
         // HARD-05: interactive=false — no operator, so an open stdin pipe is a promise tickmarkr can never
         // keep; codex exec appends a piped stdin as a <stdin> block (`codex exec --help`) and blocks on a
         // read that never EOFs. One spawn site covers every adapter (D-06).
-        // v1.22 T3: seal herdr control vars so worker/judge/review/consult children cannot reach the
-        // operator's herdr (OBS-17 watch-tab leak class). process.env of the daemon is untouched.
+        // v1.22 T3 / OBS-843: seal host control vars so worker/judge/review/consult children cannot
+        // address the operator's herdr or Orca UI. process.env of the daemon is untouched.
         const p = spawn("bash", ["-lc", cmd], {
             cwd: slot.cwd,
             stdio: ["ignore", "pipe", "pipe"],

package/dist/drivers/types.d.ts

@@ -36,6 +36,8 @@ export interface SlotOpts {
     group?: string;
     label?: string;
     owned?: OwnedName;
+    /** Adapter id for execution surfaces whose liveness support is agent-specific. */
+    agent?: string;
 }
 export declare const OWNED_ROLES: readonly ["worker", "judge", "review", "consult", "watch", "other"];
 export type OwnedRole = (typeof OWNED_ROLES)[number];