tickmarkr 2.1.5 → 2.1.6

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

@@ -0,0 +1,21 @@
+export declare const STATS_COLUMNS: readonly ["author", "reviewer", "dispatches", "deliveries", "delivery rate", "attempts to green", "real reds", "infra reds", "within-task rescues"];
+export interface ChannelStats {
+    author: string;
+    reviewers: string[];
+    dispatches: number;
+    deliveries: number;
+    deliveryRate: number;
+    /** Mean journal-recorded attempts among this channel's delivered tasks; null when it delivered none. */
+    attemptsToGreen: number | null;
+    realReds: number;
+    infraReds: number;
+    rescues: string[];
+}
+export interface StatsReport {
+    runs: number;
+    channels: ChannelStats[];
+}
+/** Reduce every readable run journal under the repository's state directory. */
+export declare function collectChannelStats(cwd?: string): StatsReport;
+export declare function renderStats(report: StatsReport): string;
+export declare function stats(argv: string[], cwd?: string): Promise<string>;

package/dist/cli/commands/stats.js

@@ -0,0 +1,210 @@
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { classifyFailureOutput } from "../../gates/baseline.js";
+import { stateDirName } from "../../graph/graph.js";
+import { Journal } from "../../run/journal.js";
+// The operator-facing schema is deliberately closed. Adding a fact to the table therefore requires
+// adding it here as a conscious compatibility change, rather than letting incidental journal fields
+// leak into an analytics surface.
+export const STATS_COLUMNS = [
+    "author",
+    "reviewer",
+    "dispatches",
+    "deliveries",
+    "delivery rate",
+    "attempts to green",
+    "real reds",
+    "infra reds",
+    "within-task rescues",
+];
+const assignmentAuthor = (data) => {
+    const assignment = data.assignment;
+    if (!assignment || typeof assignment !== "object")
+        return undefined;
+    const { adapter, model } = assignment;
+    return typeof adapter === "string" && typeof model === "string"
+        ? `${adapter}:${model}`
+        : undefined;
+};
+// Current journals write the reviewer into review prose; the structured field is also accepted so
+// journals produced through gateResultJournalData retain their stronger identity representation.
+const reviewerFrom = (data) => {
+    if (typeof data.reviewer === "string" && data.reviewer.trim())
+        return data.reviewer.trim();
+    if (typeof data.details !== "string")
+        return undefined;
+    return /\breviewer(?:\s+|:\s*)([\w@./+-]+:[\w@./+-]+)/iu.exec(data.details)?.[1];
+};
+const redEvidence = (data) => {
+    const fingerprints = Array.isArray(data.fingerprints)
+        ? data.fingerprints.filter((value) => typeof value === "string")
+        : [];
+    const prose = [data.details, data.error, data.reason]
+        .filter((value) => typeof value === "string");
+    return [...fingerprints, ...prose].join("\n");
+};
+const historyFor = (tasks, taskId) => {
+    let history = tasks.get(taskId);
+    if (!history) {
+        history = { dispatches: [], deliveries: [] };
+        tasks.set(taskId, history);
+    }
+    return history;
+};
+const dispatchedAuthorFor = (history, data) => {
+    const attempt = typeof data.attempt === "number" && Number.isInteger(data.attempt)
+        ? data.attempt
+        : undefined;
+    if (attempt !== undefined) {
+        const matched = [...history.dispatches].reverse().find((dispatch) => dispatch.attempt === attempt);
+        if (matched)
+            return matched.author;
+    }
+    return history.dispatches.at(-1)?.author;
+};
+const runIdsWithJournals = (cwd) => {
+    const runsDir = join(cwd, stateDirName(cwd), "runs");
+    if (!existsSync(runsDir))
+        return [];
+    return readdirSync(runsDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && entry.name.startsWith("run-")
+        && existsSync(join(runsDir, entry.name, "journal.jsonl")))
+        .map((entry) => entry.name)
+        .sort();
+};
+/** Reduce every readable run journal under the repository's state directory. */
+export function collectChannelStats(cwd = process.cwd()) {
+    const runIds = runIdsWithJournals(cwd);
+    const channels = new Map();
+    const channelFor = (author) => {
+        let channel = channels.get(author);
+        if (!channel) {
+            channel = {
+                author, reviewers: new Set(), dispatches: 0, deliveries: 0,
+                attemptsToGreen: 0, realReds: 0, infraReds: 0, rescues: new Set(),
+            };
+            channels.set(author, channel);
+        }
+        return channel;
+    };
+    for (const runId of runIds) {
+        const events = Journal.open(cwd, runId).read();
+        const tasks = new Map();
+        for (const [eventIndex, event] of events.entries()) {
+            if (!event.taskId)
+                continue;
+            const history = historyFor(tasks, event.taskId);
+            if (event.event === "task-dispatch") {
+                const author = assignmentAuthor(event.data);
+                if (!author)
+                    continue;
+                channelFor(author).dispatches += 1;
+                history.dispatches.push({
+                    author,
+                    ...(typeof event.data.attempt === "number" && Number.isInteger(event.data.attempt)
+                        ? { attempt: event.data.attempt }
+                        : {}),
+                    eventIndex,
+                });
+                continue;
+            }
+            if (event.event === "task-done") {
+                const author = assignmentAuthor(event.data) ?? history.dispatches.at(-1)?.author;
+                if (!author)
+                    continue;
+                const channel = channelFor(author);
+                channel.deliveries += 1;
+                const recordedAttempts = typeof event.data.attempts === "number"
+                    && Number.isInteger(event.data.attempts) && event.data.attempts >= 0
+                    ? event.data.attempts
+                    : history.dispatches.filter((dispatch) => dispatch.eventIndex < eventIndex).length;
+                channel.attemptsToGreen += recordedAttempts;
+                history.deliveries.push({ author, eventIndex });
+                continue;
+            }
+            if (event.event === "review-retry") {
+                const author = dispatchedAuthorFor(history, event.data);
+                if (!author)
+                    continue;
+                for (const reviewer of [event.data.flaked, event.data.retried]) {
+                    if (typeof reviewer === "string" && reviewer.trim())
+                        channelFor(author).reviewers.add(reviewer.trim());
+                }
+                continue;
+            }
+            if (event.event !== "gate-result")
+                continue;
+            const author = dispatchedAuthorFor(history, event.data);
+            if (!author)
+                continue;
+            const channel = channelFor(author);
+            if (event.data.gate === "review") {
+                const reviewer = reviewerFrom(event.data);
+                if (reviewer)
+                    channel.reviewers.add(reviewer);
+            }
+            if (event.data.pass !== false)
+                continue;
+            const infra = event.data.infra === true || classifyFailureOutput(redEvidence(event.data)) === "infra";
+            if (infra)
+                channel.infraReds += 1;
+            else
+                channel.realReds += 1;
+        }
+        // A rescue is task-matched, not attempt-matched: one edge says the failed author and delivering
+        // author faced the same task in the same run. Repeated attempts on the failed author do not make
+        // the task easier and therefore do not manufacture extra controlled comparisons.
+        for (const [taskId, history] of tasks) {
+            for (const delivery of history.deliveries) {
+                const failedAuthors = new Set(history.dispatches
+                    .filter((dispatch) => dispatch.eventIndex < delivery.eventIndex && dispatch.author !== delivery.author)
+                    .map((dispatch) => dispatch.author));
+                for (const failedAuthor of failedAuthors) {
+                    channelFor(delivery.author).rescues.add(`${failedAuthor} → ${delivery.author} (${runId}/${taskId})`);
+                }
+            }
+        }
+    }
+    return {
+        runs: runIds.length,
+        channels: [...channels.values()]
+            .sort((a, b) => a.author.localeCompare(b.author, "en"))
+            .map((channel) => ({
+            author: channel.author,
+            reviewers: [...channel.reviewers].sort((a, b) => a.localeCompare(b, "en")),
+            dispatches: channel.dispatches,
+            deliveries: channel.deliveries,
+            deliveryRate: channel.dispatches === 0 ? 0 : channel.deliveries / channel.dispatches,
+            attemptsToGreen: channel.deliveries === 0 ? null : channel.attemptsToGreen / channel.deliveries,
+            realReds: channel.realReds,
+            infraReds: channel.infraReds,
+            rescues: [...channel.rescues].sort((a, b) => a.localeCompare(b, "en")),
+        })),
+    };
+}
+const percent = (rate) => `${Number((rate * 100).toFixed(1))}%`;
+export function renderStats(report) {
+    const lines = [`tickmarkr stats — ${report.runs} run${report.runs === 1 ? "" : "s"}`];
+    if (report.channels.length === 0)
+        return [...lines, "no channels"].join("\n");
+    lines.push(STATS_COLUMNS.join(" | "));
+    for (const channel of report.channels) {
+        lines.push([
+            channel.author,
+            channel.reviewers.join(", ") || "—",
+            channel.dispatches,
+            channel.deliveries,
+            percent(channel.deliveryRate),
+            channel.attemptsToGreen === null ? "—" : Number(channel.attemptsToGreen.toFixed(2)),
+            channel.realReds,
+            channel.infraReds,
+            channel.rescues.join("; ") || "—",
+        ].join(" | "));
+    }
+    return lines.join("\n");
+}
+export async function stats(argv, cwd = process.cwd()) {
+    if (argv.length > 0)
+        throw new Error("stats takes no run id — it reads every run in the state directory");
+    return renderStats(collectChannelStats(cwd));
+}

package/dist/cli/commands/status.js

@@ -7,7 +7,7 @@ import { formatOwnedName, parseOwnedName, } from "../../drivers/types.js";
 import { blockedTasks, graphDefinitionHash, loadGraph, stateDirName } from "../../graph/graph.js";
 import { GATE_NAMES } from "../../graph/schema.js";
 import { foldActivity } from "../../run/activity.js";
-import { Journal, engagementComparable, isQualityFailureParkKind, recordedTaskFailureKind, runHasEnded, } from "../../run/journal.js";
+import { Journal, engagementComparable, isQualityFailureParkKind, preservedRefsByTask, recordedTaskFailureKind, runHasEnded, upheldFeedbackByTask, } from "../../run/journal.js";
 import { isPidLive } from "../../run/lock.js";
 import { normalizeGateOutcome } from "../../run/outcome.js";
 import { desiredPanes } from "../../run/reconcile.js";
@@ -979,6 +979,21 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
         if (!taskIds.has(taskId))
             phases.delete(taskId);
     const hotPhase = [...phases.values()].sort((a, b) => a.order - b.order).at(-1);
+    // OBS-738: recovery facts stay on the journal's two established reducers. The prefix fold keeps an
+    // older journal equally readable by asking upheldFeedbackByTask what was active at that exact
+    // restore boundary; current resume-restore rows additionally carry the same task for narration.
+    const preservedRefs = preservedRefsByTask(events);
+    const restoredUpheldFeedback = new Set(events.flatMap((event, index) => event.event === "resume-restore" && event.taskId
+        && upheldFeedbackByTask(events.slice(0, index)).has(event.taskId)
+        ? [event.taskId]
+        : []));
+    const recoveryLinesForTask = (taskId) => [
+        ...(preservedRefs.get(taskId) ?? []).flatMap(({ ref, diffCommand }) => [
+            `preserved worktree — ${taskId} — ${ref}`,
+            `  ${diffCommand}`,
+        ]),
+        ...(restoredUpheldFeedback.has(taskId) ? [`upheld feedback restored for ${taskId}`] : []),
+    ].map(sanitizeTaskText);
     const cells = renderedTasks.map((t) => {
         const folded = journalRowsOnly && comparable ? taskRows.get(t.id) : undefined;
         const st = folded?.state ?? replayed?.get(t.id) ?? t.status;
@@ -1011,7 +1026,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
     if (!unicode) {
         // machine/CI surface — journals without phase-start stay byte-identical; new phase-aware frames
         // use an ASCII spinner so pipes never receive terminal-only braille/ANSI.
-        const rows = cells.map(({ t, st, merged, label, assignCol, livePhase, states, priorGraph, pane }) => {
+        const rows = cells.flatMap(({ t, st, merged, label, assignCol, livePhase, states, priorGraph, pane }) => {
             const chain = gateChain(states, false);
             const prefix = livePhase ? `  ${ASCII_SPINNER[animationFrame % ASCII_SPINNER.length]} ${t.id} ` : `  ${surfaceTaskBox(st, merged)} ${t.id} `;
             const suffix = `  ${chain}${priorGraph ? ` ${PRIOR_GRAPH_MARKER}` : ""}  ${livePhase ? "running" : surfaceStatusWord(st)}${label}  ${assignCol}${pane ? `  pane ${pane}` : ""}`;
@@ -1020,7 +1035,10 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
             // can exceed the terminal width, and the pre-floor math paid for it out of the TITLE — 20 of
             // 41 rows in a live 41-task run named no task at all. These rows already overflow `width`
             // (a pane name is 60 columns on its own), so the floor costs wrapping, never the graph.
-            return `${prefix}${shortGoal(t.title, Math.max(MACHINE_TITLE_FLOOR, width - prefix.length - suffix.length))}${suffix}`;
+            return [
+                `${prefix}${shortGoal(t.title, Math.max(MACHINE_TITLE_FLOOR, width - prefix.length - suffix.length))}${suffix}`,
+                ...recoveryLinesForTask(t.id).map((line) => `    ${line}`),
+            ];
         });
         const zone = journalRowsOnly ? `${divider}zone ${localZoneLabel(zoneReference)}` : "";
         const header = runId
@@ -1210,6 +1228,12 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
         return [legend(headerRow), dim(ruleRow), ...rows];
     };
     const gatesLegend = legend(`    gates   ${GATE_NAMES.map((gate) => `${gate.slice(0, 2)} ${gate}`).join("  ")}`);
+    const recoveryLines = cells.flatMap((cell) => recoveryLinesForTask(cell.t.id));
+    const recoverySection = recoveryLines.length === 0 ? [] : [
+        "",
+        `  ${ok("▌")} ${title("RECOVERY")}`,
+        ...recoveryLines.map((line) => legend(`    ${line}`)),
+    ];
     const effort = effortPanel(g.tasks, record && !comparable ? undefined : events, boardColumns);
     return {
         content: boardRows([
@@ -1220,6 +1244,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
             taskSection,
             "",
             ...tableRows(),
+            ...recoverySection,
             gatesLegend,
             "",
             rule(boardColumns),

package/dist/cli/index.d.ts

@@ -5,7 +5,7 @@ export type CommandResult = string | {
 };
 export type CommandMap = Record<string, (argv: string[]) => Promise<CommandResult>>;
 export declare const COMMANDS: CommandMap;
-export declare const USAGE = "tickmarkr \u2014 spec-driven orchestration harness for AI coding agents\nusage: tickmarkr <command>\n  init          guided setup + doctor; init --agent [--force] [--docs] adds agent skills/docs\n  doctor        re-probe adapters, herdr, auth; print capability matrix (--fix writes the test-runner ignore when a safe edit exists)\n  fleet         interactive fleet editor (fleet --print for CI drift checks)\n  compile <src> spec \u2192 .tickmarkr/graph.json (fails without acceptance criteria)\n  scope <intent> draft a compiled native spec beside an answered intent (--force to overwrite)\n  plan          dry-run routing table + cost estimate + floor lints\n  eval          run checked-in fixtures against every channel in isolated temp repos\n  run           execute the graph (--concurrency N --driver auto|herdr|subprocess|orca --route-strict; orca runs only when named)\n  status        live run state\n  verify        run the gate battery standalone against merge-base(--base, HEAD)..HEAD \u2014 no daemon, one verdict (--base main --criteria <file> | --task <id> [--files <glob>] [--author adapter:model] [--no-review] [--json])\n  resume <id>   continue a run from its journal\n  report <id>   cost/quality report (--md for committable execution record)\n  profile       show learned routing profile (profile reset = forget history via cursor, keeps telemetry)\n  ui            open the Fleet Studio TUI (full-screen tabbed cockpit)\n  unlock        remove a stale/garbage run lock (refuses if the holder is alive)\n  beat <tier>   record one supervision beat for orchestrator|orchestrator-context|overseer|overseer-context|watch, --seat <identity> required (--stand-down to hand off); a supervising seat's own watcher loop calls it, and status reads the tier STALE once the beats stop\n  approve <id> <task>  release a park (--uphold sides with the reviewer and funds a fixed attempt; --by <name> --reason <text>); takes effect on resume";
+export declare const USAGE = "tickmarkr \u2014 spec-driven orchestration harness for AI coding agents\nusage: tickmarkr <command>\n  init          guided setup + doctor; init --agent [--force] [--docs] adds agent skills/docs\n  doctor        re-probe adapters, herdr, auth; print capability matrix (--fix writes the test-runner ignore when a safe edit exists)\n  fleet         interactive fleet editor (fleet --print for CI drift checks)\n  compile <src> spec \u2192 .tickmarkr/graph.json (fails without acceptance criteria)\n  scope <intent> draft a compiled native spec beside an answered intent (--force to overwrite)\n  plan          dry-run routing table + cost estimate + floor lints\n  eval          run checked-in fixtures against every channel in isolated temp repos\n  run           execute the graph (--concurrency N --driver auto|herdr|subprocess|orca --route-strict; orca runs only when named)\n  status        live run state\n  stats         all-run channel delivery, red, rescue, author and reviewer statistics\n  verify        run the gate battery standalone against merge-base(--base, HEAD)..HEAD \u2014 no daemon, one verdict (--base main --criteria <file> | --task <id> [--files <glob>] [--author adapter:model] [--no-review] [--json])\n  resume <id>   continue a run from its journal\n  report <id>   cost/quality report (--md for committable execution record)\n  profile       show learned routing profile (profile reset = forget history via cursor, keeps telemetry)\n  ui            open the Fleet Studio TUI (full-screen tabbed cockpit)\n  unlock        remove a stale/garbage run lock (refuses if the holder is alive)\n  beat <tier>   record one supervision beat for orchestrator|orchestrator-context|overseer|overseer-context|watch, --seat <identity> required (--stand-down to hand off); a supervising seat's own watcher loop calls it, and status reads the tier STALE once the beats stop\n  approve <id> <task>  release a park (--uphold sides with the reviewer and funds a fixed attempt; --by <name> --reason <text>); takes effect on resume";
 export declare function dispatch(cmd: string | undefined, argv: string[], commands?: CommandMap): Promise<{
     out: string;
     code: number;

package/dist/cli/index.js

@@ -14,6 +14,7 @@ import { report } from "./commands/report.js";
 import { resume } from "./commands/resume.js";
 import { run } from "./commands/run.js";
 import { scope } from "./commands/scope.js";
+import { stats } from "./commands/stats.js";
 import { status } from "./commands/status.js";
 import { ui } from "./commands/ui.js";
 import { unlock } from "./commands/unlock.js";
@@ -21,7 +22,7 @@ import { verify } from "./commands/verify.js";
 import { version } from "./commands/version.js";
 const normalize = (r) => typeof r === "string" ? { out: r, code: 0 } : r;
 export const COMMANDS = {
-    init, doctor, fleet, compile, scope, plan, run, status, resume, report, profile, ui, unlock, approve, beat, version, verify, eval: evalCommand,
+    init, doctor, fleet, compile, scope, plan, run, status, stats, resume, report, profile, ui, unlock, approve, beat, version, verify, eval: evalCommand,
 };
 const VERSION_FLAGS = new Set(["version", "--version", "-v"]);
 const HELP_CMDS = new Set(["help", "-h", "--help"]);
@@ -37,6 +38,7 @@ usage: tickmarkr <command>
   eval          run checked-in fixtures against every channel in isolated temp repos
   run           execute the graph (--concurrency N --driver auto|herdr|subprocess|orca --route-strict; orca runs only when named)
   status        live run state
+  stats         all-run channel delivery, red, rescue, author and reviewer statistics
   verify        run the gate battery standalone against merge-base(--base, HEAD)..HEAD — no daemon, one verdict (--base main --criteria <file> | --task <id> [--files <glob>] [--author adapter:model] [--no-review] [--json])
   resume <id>   continue a run from its journal
   report <id>   cost/quality report (--md for committable execution record)

package/dist/gates/baseline.js

@@ -117,7 +117,7 @@ const VOCAB_RE = /\b(?:error|fail(?:ed|ure|ing)?)\b/i;
 // shapes are emitted by the process that was asked to run the oracle; they are deliberately kept in
 // this runner-output classifier rather than applied to any judge-authored reason text. A real test
 // failure still dominates below because one regression-shaped line makes the whole output regression.
-const INFRA_RE = /\bE(?:AGAIN|MFILE|NFILE|NOMEM|NOSPC)\b|JavaScript heap out of memory|Cannot allocate memory|Resource temporarily unavailable|Token not found in system keyring|Process from config\.webServer was not able to start/i;
+const INFRA_RE = /\bE(?:AGAIN|MFILE|NFILE|NOMEM|NOSPC)\b|JavaScript heap out of memory|Cannot allocate memory|Resource temporarily unavailable|Token not found in system keyring|Process from config\.webServer was not able to start|\[birpc\] rpc is closed, cannot call\b/i;
 // Capture invalidation is deliberately narrower than the gate's infrastructure vocabulary above:
 // keyring/config-webServer startup failures remain gate concerns, while this policy is specifically
 // for evidence that the capture ran while the machine was resource-starved.
@@ -127,6 +127,12 @@ const CAPTURE_EXHAUSTION_RE = /\bE(?:AGAIN|MFILE|NFILE|NOMEM|NOSPC)\b|JavaScript
 const ERROR_CLASS_RE = /\b[A-Za-z][A-Za-z0-9]*Error\b/;
 const isInfraLine = (l) => INFRA_RE.test(l) && !ERROR_CLASS_RE.test(l) && !namesFailure(l) && !SUMMARY_FAIL_RE.test(l);
 const namesRegression = (l) => (isFailureShaped(l) || ERROR_CLASS_RE.test(l)) && !isInfraLine(l);
+// Infrastructure signatures must enter the fingerprint diff too. Otherwise a signature such as
+// birpc's assertion-free RPC death is classified correctly in the raw output but collapses to the
+// content-free UNRECOGNIZED_FAILURE marker before the fresh-failure path can ask the same classifier.
+// This does not make the vocabulary open-ended: INFRA_RE is still the one closed list, and
+// classifyFailureOutput's ERROR_CLASS_RE/namesFailure vetoes still decide mixed lines.
+const isFingerprintShaped = (l) => isFailureShaped(l) || INFRA_RE.test(l);
 /**
  * What a nonzero runner exit is evidence OF. `undefined` when the output names neither — the
  * unreadable-runner case the existing fail-closed path already owns.
@@ -196,10 +202,10 @@ export function fingerprint(output) {
     // prefixed form keeps fingerprinting too (baseline-recorded package-level reds stay forgivable).
     const shaped = [];
     for (const l of lines) {
-        if (isFailureShaped(l))
+        if (isFingerprintShaped(l))
             shaped.push(l);
         const stripped = stripTurboPrefix(l);
-        if (stripped !== undefined && !PASS_LINE_RE.test(stripped) && isFailureShaped(stripped))
+        if (stripped !== undefined && !PASS_LINE_RE.test(stripped) && isFingerprintShaped(stripped))
             shaped.push(stripped);
     }
     if (!shaped.length)
@@ -544,21 +550,6 @@ export async function compareToBaseline(cwd, commands, baseline, enabled) {
             continue;
         }
         const raw = (r.stdout + "\n" + r.stderr).split(cwd).join("");
-        // T9: classify BEFORE the baseline diff, and record it on every nonzero result. An infra-only
-        // exit means the runner never completed a suite, so there is nothing to forgive and nothing
-        // verified — it fails, and `meta.infra` marks it so the merge predicate cannot read it as a
-        // satisfied gate even if some future producer reports it as a pass. Baseline forgiveness stays
-        // exactly where it belongs: on failures the runner actually reported and the baseline already had.
-        const classification = classifyFailureOutput(raw);
-        if (classification === "infra") {
-            record({
-                gate: name,
-                pass: false,
-                details: `exit ${r.code} on infrastructure alone — the runner never completed a suite, so this gate verified nothing:\n${unrecognizedEvidence(raw) || raw.trim().split("\n").slice(0, 10).join("\n")}`,
-                meta: { classification, infra: true },
-            });
-            continue;
-        }
         // OBS-278: only a failure SHAPE is a verdict — everything fingerprint() keeps is one, except the
         // unrecognized-output marker, which is evidence for the operator and never grounds to reject.
         // ponytail: ceiling — a runner whose failure output holds no shape above and whose baseline is
@@ -567,6 +558,25 @@ export async function compareToBaseline(cwd, commands, baseline, enabled) {
         // that runner's position rule (leading verdict + identifier, or identifier + separator + trailing
         // verdict); loosening back to vocabulary re-opens OBS-278.
         const { failing, unreadable } = freshFailures(entry, raw);
+        // T9: classify the FRESH diff before charging it. The complete runner output can legitimately
+        // contain a baseline-recorded assertion beside a newly introduced infrastructure death; letting
+        // that known assertion outvote the fresh birpc line turns machine failure into a worker defect.
+        // `classifyFailureOutput` remains the single discriminator. When there is no fresh fingerprint,
+        // retain the whole-output read so a repeated infra abort can never be baseline-forgiven as green.
+        const freshClassification = failing.length ? classifyFailureOutput(failing.join("\n")) : undefined;
+        const classification = freshClassification ?? (!failing.length ? classifyFailureOutput(raw) : undefined);
+        if (classification === "infra") {
+            const evidence = failing.length
+                ? failing.slice(0, 10).join("\n")
+                : unrecognizedEvidence(raw) || raw.trim().split("\n").slice(0, 10).join("\n");
+            record({
+                gate: name,
+                pass: false,
+                details: `exit ${r.code}; the fresh failures carry infrastructure evidence alone — the runner never completed a suite, so this gate verified nothing:\n${evidence}`,
+                meta: { classification, infra: true },
+            });
+            continue;
+        }
         // OBS-534 (T2): only a recorded VERDICT can be forgiven. A green baseline has no red to forgive,
         // and neither has a capture that was killed at its ceiling — it recorded a cause instead, so it
         // fails closed on the same branch rather than reading as "only pre-existing failures". Legacy

package/dist/run/daemon.js

@@ -521,6 +521,35 @@ async function gateCommitSubject(base, head, wt) {
         return head; // fail closed to the exact object id if canonicalization fails
     return createHash("sha256").update(history.stdout).digest("hex");
 }
+// A CPU total cannot prove a tree empty: a newly launched live process can still have a measured
+// total of zero at the host's clock resolution. This probe asks the narrower cardinality question
+// OBS-737 needs. A readable process table with no marker root is measured empty; a failed or empty
+// table is unmeasurable. Descendants are closed over PPID because not every child retains the
+// dispatch-script marker in its own argv.
+async function observeWorkerProcessTree(marker, cwd) {
+    const snapshot = await shGit("ps -Awwo pid=,ppid=,command=", cwd, 15_000);
+    if (snapshot.code !== 0)
+        return "unmeasurable";
+    const rows = [];
+    for (const line of snapshot.stdout.split("\n")) {
+        const match = /^\s*(\d+)\s+(\d+)\s+(.*)$/.exec(line);
+        if (match)
+            rows.push({ pid: match[1], ppid: match[2], command: match[3] });
+    }
+    if (rows.length === 0)
+        return "unmeasurable";
+    const tree = new Set(rows.filter((row) => row.command.includes(marker)).map((row) => row.pid));
+    for (let grew = true; grew;) {
+        grew = false;
+        for (const row of rows) {
+            if (!tree.has(row.pid) && tree.has(row.ppid)) {
+                tree.add(row.pid);
+                grew = true;
+            }
+        }
+    }
+    return tree.size === 0 ? "empty" : "running";
+}
 const OBSERVE_CHUNK_BYTES = 64 * 1024;
 const OBSERVE_BUDGET_BYTES = 256 * 1024 * 1024;
 let observeBudgetBytes = OBSERVE_BUDGET_BYTES;
@@ -605,6 +634,20 @@ async function boundedGitObservation(command, worktree, budget) {
         return undefined;
     return result.stdout;
 }
+// "No worktree delta" means no staged/unstaged/untracked bytes AND no commits beyond the task's
+// dispatch base. Both reads are bounded and preserve the observer's third state: a failed probe is
+// unreadable, never clean.
+async function observeWorktreeDelta(base, worktree) {
+    let budget = observeBudgetBytes;
+    const status = await boundedGitObservation("GIT_OPTIONAL_LOCKS=0 git status --porcelain=v1 -z --untracked-files=all", worktree, budget);
+    if (status === undefined)
+        return "unreadable";
+    budget -= Buffer.byteLength(status);
+    const ahead = await boundedGitObservation(`GIT_OPTIONAL_LOCKS=0 git rev-list --count ${shq(base)}..HEAD`, worktree, budget);
+    if (ahead === undefined || !/^\d+$/.test(ahead.trim()))
+        return "unreadable";
+    return status.length === 0 && ahead.trim() === "0" ? "unchanged" : "changed";
+}
 // The signature has four git-owned inputs: HEAD, staged blob/mode/path identity, porcelain path and
 // state, and the set of worktree paths whose bytes Git cannot supply. Those paths contribute their
 // filesystem identity, mode, symlink text, and content. A failed or over-budget leg is a third
@@ -1091,10 +1134,10 @@ export async function runDaemon(repoRoot, opts = {}) {
             };
             // gateFails/consults are execTask-scoped counters passed in so a park row is a rich verified-failure
             // observation (e.g. ladder-exhausted + gateFails:4); every task-human row has a closed kind, never prose alone.
-            const park = async (t, reason, kind, assignment, attempts, startMs, gateFails = 0, consults = 0, tokens, metered = 0, retryMode = "fresh") => {
+            const park = async (t, reason, kind, assignment, attempts, startMs, gateFails = 0, consults = 0, tokens, metered = 0, retryMode = "fresh", details = {}) => {
                 graph = setStatus(graph, t.id, "human");
                 saveGraph(repoRoot, graph);
-                journal.append("task-human", t.id, { reason, kind });
+                journal.append("task-human", t.id, { ...details, reason, kind });
                 if (assignment) {
                     // OBS-547: `metered` counts CHARGEABLE metered attempts, so an unchargeable dispatch passes 0 and
                     // the count is omitted rather than written as 0 or as `1` beside `attempts: 0` — a row claiming
@@ -1172,6 +1215,22 @@ export async function runDaemon(repoRoot, opts = {}) {
                         journal.append("worktree-preserved", t.id, { ref });
                     return driver.worktree(repoRoot, taskBranch, taskBase);
                 };
+                // A dead worker with a clean checkout still needs a durable recovery handle: there may be no
+                // pane left to identify even the commit it was dispatched from. preserveWorktree deliberately
+                // creates no ref for ordinary clean recreations, so this exceptional terminal path pins HEAD
+                // explicitly under the same recovery namespace. Reconfirm the delta immediately before the
+                // ref write; a change or unreadable recheck withdraws the park.
+                const preserveDeadWorker = async (worktree, taskBase) => {
+                    const state = await observeWorktreeDelta(taskBase, worktree);
+                    if (state !== "unchanged")
+                        return { state };
+                    const head = await gitHead(worktree);
+                    const ref = `refs/tickmarkr/preserved/${head}`;
+                    const updated = await shGit(`git update-ref ${shq(ref)} ${shq(head)}`, worktree);
+                    if (updated.code !== 0)
+                        throw new Error(`could not preserve dead worker HEAD at ${ref}: ${updated.stderr || updated.stdout}`);
+                    return { state, ref };
+                };
                 const r = route(t, cfg, channels, profile, undefined, demotedChannels);
                 for (const lint of r.lints)
                     journal.append("routing-lint", t.id, { lint });
@@ -2184,6 +2243,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                     // subprocess tree that REACHED its exit marker, not about what the worker claimed.
                     let processExited = false;
                     let earlyLaunchDead = false;
+                    let deadWorkerPark;
                     let settleParsed;
                     let seedResult;
                     // v1.22 T5 / OBS-19: auto-answer a fingerprint-matched trust dialog exactly once per slot.
@@ -2323,6 +2383,8 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 let quotaStreak = 0;
                                 let rowSaturationHeld = false; // journaled once per attempt when the kill stands down
                                 let cpuHeld = false; // likewise for the CPU leg's stand-down (OBS-548)
+                                let paneReadHeld = false;
+                                let paneStatusHeld = false;
                                 while (Date.now() - lastProgressAt < stallWindowMs) {
                                     const sliceStart = Date.now();
                                     const remaining = stallWindowMs - (sliceStart - lastProgressAt);
@@ -2350,7 +2412,39 @@ export async function runDaemon(repoRoot, opts = {}) {
                                             break;
                                         }
                                     }
-                                    const paneText = await driver.read(slot, PANE_READ_ROWS);
+                                    // A failed pane read is absence of evidence, never evidence of an absent pane. Keep the
+                                    // rolling taskTimeoutMinutes window as the backstop and name the held probe once.
+                                    let paneText;
+                                    try {
+                                        paneText = await driver.read(slot, PANE_READ_ROWS);
+                                    }
+                                    catch (error) {
+                                        // Preserve the pre-existing exception path when the independent status probe still
+                                        // sees a pane. The outer attempt finally owns accountant cleanup on that path. Only
+                                        // an undetectable status makes the read failure relevant to the death detector, and
+                                        // that genuinely unmeasurable pair fails open to the rolling timeout.
+                                        let paneUndetectable = true;
+                                        try {
+                                            paneUndetectable = await driver.status(slot) === "unknown";
+                                        }
+                                        catch {
+                                            // Two unreadable pane probes are still unmeasurable, never proof of death.
+                                        }
+                                        if (!paneUndetectable)
+                                            throw error;
+                                        if (!paneReadHeld) {
+                                            paneReadHeld = true;
+                                            journal.append("worker-dead-held", t.id, {
+                                                slot: slot.name, attempt, reason: "pane-read-unreadable",
+                                                error: error instanceof Error ? error.message : String(error),
+                                            });
+                                        }
+                                        await armCpuLeg(false);
+                                        const spent = Date.now() - sliceStart;
+                                        if (spent < slice)
+                                            await new Promise((r) => setTimeout(r, Math.min(slice - spent, 1_000)));
+                                        continue;
+                                    }
                                     if (paneText.length > 0)
                                         everHadOutput = true;
                                     // OBS-117 (v1.71 T6): zero raw output by the early-launch deadline is a dead channel now.
@@ -2419,7 +2513,24 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     // gate held. page on "idle" too: herdr's blocked-scrape is strict and proved flaky
                                     // for TUI dialogs (live check: cursor's trust dialog scraped as idle).
                                     // "unknown"/"working" never page.
-                                    const st = await driver.status(slot);
+                                    let st;
+                                    try {
+                                        st = await driver.status(slot);
+                                    }
+                                    catch (error) {
+                                        if (!paneStatusHeld) {
+                                            paneStatusHeld = true;
+                                            journal.append("worker-dead-held", t.id, {
+                                                slot: slot.name, attempt, reason: "pane-status-unreadable",
+                                                error: error instanceof Error ? error.message : String(error),
+                                            });
+                                        }
+                                        await armCpuLeg(false);
+                                        const spent = Date.now() - sliceStart;
+                                        if (spent < slice)
+                                            await new Promise((r) => setTimeout(r, Math.min(slice - spent, 1_000)));
+                                        continue;
+                                    }
                                     if (st !== lastStatus) {
                                         lastStatus = st;
                                         journal.append("worker-status", t.id, { slot: slot.name, status: st, attempt });
@@ -2459,6 +2570,95 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     // daemon has nothing left to do — the pane falls back under the fast-kill and page
                                     // watchdogs like any other, instead of riding the whole rolling window untended.
                                     const nudgePending = nudgeable && (!nudged || nudgeDeadline !== undefined);
+                                    // OBS-737: disposition for the one fully measured death state. `unknown` alone is not
+                                    // absence (status parsing can fail), and an empty read alone is not absence (a live pane
+                                    // can be quiet); together they are the existing driver-level pane absence witness. The
+                                    // process probe and both worktree observations retain their own third states. Only the
+                                    // explicit conjunction parks; every other state falls through to the unchanged rolling
+                                    // timeout below. Seeded launches are excluded because their process marker is knowingly
+                                    // unmeasurable (armCpuLeg documents that contract above).
+                                    const paneAbsentCandidate = st === "unknown" && paneText.trim().length === 0;
+                                    // A subprocess can exit between waitOutput and read while its stdout is still draining.
+                                    // Confirm emptiness in this same poll before paying for `ps`; then confirm once more
+                                    // after the process probe yielded the event loop. Any bytes or read error withdraw the
+                                    // absence witness, so a fast completed worker cannot be parked in that drain race.
+                                    let paneAbsent = paneAbsentCandidate;
+                                    if (paneAbsent) {
+                                        try {
+                                            const confirmation = await driver.read(slot, PANE_READ_ROWS);
+                                            paneAbsent = confirmation.trim().length === 0;
+                                            if (!paneAbsent) {
+                                                everHadOutput = true;
+                                                if (stallProgress.observe({ paneText: confirmation, contextTokens }))
+                                                    lastProgressAt = Date.now();
+                                            }
+                                        }
+                                        catch (error) {
+                                            paneAbsent = false;
+                                            if (!paneReadHeld) {
+                                                paneReadHeld = true;
+                                                journal.append("worker-dead-held", t.id, {
+                                                    slot: slot.name, attempt, reason: "pane-read-unreadable",
+                                                    error: error instanceof Error ? error.message : String(error),
+                                                });
+                                            }
+                                        }
+                                    }
+                                    const processTree = paneAbsent && worktreeSinceLaunch === "unchanged" && !hasSeed
+                                        ? await observeWorkerProcessTree(dispatchScript, wt)
+                                        : "unmeasurable";
+                                    if (processTree === "empty") {
+                                        try {
+                                            const confirmation = await driver.read(slot, PANE_READ_ROWS);
+                                            paneAbsent = confirmation.trim().length === 0;
+                                            if (!paneAbsent) {
+                                                everHadOutput = true;
+                                                if (stallProgress.observe({ paneText: confirmation, contextTokens }))
+                                                    lastProgressAt = Date.now();
+                                            }
+                                        }
+                                        catch (error) {
+                                            paneAbsent = false;
+                                            if (!paneReadHeld) {
+                                                paneReadHeld = true;
+                                                journal.append("worker-dead-held", t.id, {
+                                                    slot: slot.name, attempt, reason: "pane-read-unreadable",
+                                                    error: error instanceof Error ? error.message : String(error),
+                                                });
+                                            }
+                                        }
+                                    }
+                                    const worktreeDelta = processTree === "empty"
+                                        && paneAbsent ? await observeWorktreeDelta(taskBase, wt)
+                                        : "unreadable";
+                                    // The first process snapshot can race a just-starting child after the dispatch pane
+                                    // disappeared. Re-read it after the pane and worktree legs have both held: preservation
+                                    // is terminal, so a process appearing in that interval must withdraw the park rather
+                                    // than be orphaned by it. The final worktree recheck remains inside preserveDeadWorker.
+                                    const confirmedProcessTree = worktreeDelta === "unchanged"
+                                        ? await observeWorkerProcessTree(dispatchScript, wt)
+                                        : "unmeasurable";
+                                    const deathCertain = paneAbsent
+                                        && processTree === "empty"
+                                        && confirmedProcessTree === "empty"
+                                        && worktreeDelta === "unchanged";
+                                    if (deathCertain) {
+                                        const preservation = await preserveDeadWorker(wt, taskBase);
+                                        if (!preservation.ref) {
+                                            journal.append("worker-dead-held", t.id, {
+                                                slot: slot.name, attempt, reason: `worktree-${preservation.state}`,
+                                            });
+                                            continue;
+                                        }
+                                        const ref = preservation.ref;
+                                        const reason = `worker is unambiguously dead: pane absent, process tree empty, and worktree unchanged; preserved at ${ref}`;
+                                        deadWorkerPark = { ref, reason };
+                                        journal.append("worktree-preserved", t.id, { ref });
+                                        journal.append("worker-dead-held", t.id, {
+                                            slot: slot.name, attempt, reason: "unambiguous-worker-death", ref,
+                                        });
+                                        break;
+                                    }
                                     // T1 review fix: the kill's "no output growth" leg clocks off the RAW growth signals,
                                     // never lastProgressAt alone — the flat-token rule (stall.ts) deliberately suppresses
                                     // the re-arm report on row growth once tokens stick, and contextTokens is sticky across
@@ -2632,7 +2832,13 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 if (!finished && exitCode === null) {
                                     // timed out (or only ever saw false positives): harvest whatever the pane holds now
                                     timedOut = Date.now() - lastProgressAt >= stallWindowMs;
-                                    output = await driver.read(slot, PANE_READ_ROWS);
+                                    try {
+                                        output = await driver.read(slot, PANE_READ_ROWS);
+                                    }
+                                    catch {
+                                        // The poll loop already recorded the unreadable pane. Retain the last readable bytes
+                                        // so this ambiguous path still reaches the ordinary timeout/consult backstop.
+                                    }
                                     finished = new RegExp(trailerPattern(nonce)).test(output);
                                     const exit = exitRe.exec(output);
                                     exitCode = exit ? Number(exit[1]) : null;
@@ -2766,6 +2972,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                         tokens = addUsage(tokens, attemptUsage);
                         metered++;
                     }
+                    if (deadWorkerPark) {
+                        await park(t, deadWorkerPark.reason, "stall", assignment, attempt + 1, startMs, gateFails, consults, tokens, metered, retryMode, { ref: deadWorkerPark.ref });
+                        return;
+                    }
                     let result = settleParsed ?? adapter.parse(output, nonce);
                     const workerFinished = finished;
                     const workerCause = classifyWorkerResultCause({ output, ok: result.ok, finished, exitCode, summary: result.summary, timedOut, deadChannel: deadChannelKilled });

package/dist/run/journal.d.ts

@@ -29,6 +29,11 @@ export declare const ATTEMPT_CAP_RELEASE: "attempt-cap";
 export declare const GATE_SATISFIED_RELEASE: "gate-satisfied";
 export declare const REVIEW_UPHELD_RELEASE: "review-upheld";
 export declare const RECHECK_RELEASE: "recheck";
+export interface PreservedRef {
+    ref: string;
+    diffCommand: string;
+}
+export declare function preservedRefsByTask(events: JournalEvent[]): Map<string, PreservedRef[]>;
 export declare function reviewRoundsSinceApproval(events: JournalEvent[], taskId: string): number;
 export declare function upheldFeedbackByTask(events: JournalEvent[]): Map<string, string>;
 export interface StructuredFinding {

package/dist/run/journal.js

@@ -2,7 +2,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
-import { channelKey, TokenUsageSchema } from "../adapters/types.js";
+import { channelKey, shq, TokenUsageSchema } from "../adapters/types.js";
 import { stateDirName, taskContentDigest, tickmarkrDir } from "../graph/graph.js";
 import { GATE_NAMES, TIERS } from "../graph/schema.js";
 import { buildProfile, classify } from "../route/profile.js";
@@ -56,6 +56,24 @@ export const REVIEW_UPHELD_RELEASE = "review-upheld";
 // so the corrected declaration is the thing that earns the green. Budget semantics match attempt-cap
 // (fresh attempts, tried survives) because the park cost the task its remaining budget.
 export const RECHECK_RELEASE = "recheck";
+// OBS-738: one authority for every recovery surface. The ref is accepted only from the row that
+// preservation itself writes; task-human prose, branch heads and commit history are deliberately
+// absent from this fold. Keep every row in journal order — one task can be recreated more than once,
+// and the terminal record owes the operator every resulting recovery handle, not merely the newest.
+export function preservedRefsByTask(events) {
+    const byTask = new Map();
+    for (const event of events) {
+        if (event.event !== "worktree-preserved" || !event.taskId || typeof event.data.ref !== "string"
+            || event.data.ref === "")
+            continue;
+        const ref = event.data.ref;
+        byTask.set(event.taskId, [
+            ...(byTask.get(event.taskId) ?? []),
+            { ref, diffCommand: `git diff ${shq(`${ref}^!`)}` },
+        ]);
+    }
+    return byTask;
+}
 // OBS-189: review rounds are scoped to the current ENGAGEMENT — the stretch since the newest operator
 // approval for the task. A whole-journal count re-parks an upheld task before its funded attempt can
 // dispatch (measured live on run-20260726-213539), making a fresh journal the only escape. A T15
@@ -1069,19 +1087,36 @@ export class Journal {
             ? undefined
             : DecisionEventSchema.parse({ ...eventOrDecision, ts: new Date().toISOString() });
         const event = decisionRow?.event ?? eventOrDecision;
+        const rowTaskId = decisionRow && "taskId" in decisionRow ? decisionRow.taskId : taskId;
         const inputData = decisionRow?.data ?? data;
+        // OBS-738: terminal and resume records reduce the journal that precedes them. Neither re-derives
+        // recovery facts from task-human prose: preserved refs come from preservedRefsByTask, and the
+        // upheld brief comes from the established prompt/replay reducer.
+        const priorEvents = event === "run-end" || event === "resume-restore" ? this.read() : [];
+        const reducedData = event === "run-end"
+            ? (() => {
+                const preservedRefs = [...preservedRefsByTask(priorEvents)].flatMap(([preservedTaskId, refs]) => refs.map(({ ref, diffCommand }) => ({ taskId: preservedTaskId, ref, diffCommand })));
+                return preservedRefs.length > 0 ? { ...inputData, preservedRefs } : inputData;
+            })()
+            : event === "resume-restore" && rowTaskId && upheldFeedbackByTask(priorEvents).has(rowTaskId)
+                ? {
+                    ...inputData,
+                    upheldFeedbackRestoredFor: rowTaskId,
+                    summary: `upheld feedback restored for ${rowTaskId}`,
+                }
+                : inputData;
         const evidence = judgePersistence.getStore();
         const failed = evidence?.invocations.filter((invocation) => invocation.transcript !== undefined) ?? [];
         const persistedData = event === "judge-retry" && failed.length > 0
             ? {
-                ...inputData,
+                ...reducedData,
                 transcript: failed[0].transcript,
                 ...(failed[1] ? { retryTranscript: failed[1].transcript } : {}),
             }
-            : inputData;
-        const row = decisionRow ?? {
-            ts: new Date().toISOString(), event, ...(taskId ? { taskId } : {}), data: persistedData,
-        };
+            : reducedData;
+        const row = decisionRow
+            ? { ...decisionRow, data: persistedData }
+            : { ts: new Date().toISOString(), event, ...(taskId ? { taskId } : {}), data: persistedData };
         // T3 secret redaction: only the persisted bytes are masked — the caller's data stays untouched in
         // memory. The narrator receives the persisted (masked) row so a pane sink never shows a credential.
         const line = redactSecrets(JSON.stringify(row));

package/package.json

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

package/skills/tickmarkr-overseer/SKILL.md

@@ -103,7 +103,7 @@ through brief lineage. **An executor choice nobody made is still an executor cho
    fraction (`ORCH · v1.19 4/5`, updated on every task-done); tickmarkr opens ONE TAB PER TASK, labelled
    with the task id and holding that task's worker plus its judge/review/consult panes (tickmarkr
    updates it). Never long context strings or ✓-chains.
-2. **Orchestrator**: Launch the orchestrator with your agent host. Spawning on current herdr is two-step — the one-shot `agent start --cwd` form was removed in the herdr CLI redesign and now fails with `unknown option` (OBS-138): first create the pane with `herdr tab create --workspace <ws> --cwd <repo> --label "ORCH · <version>"` and parse `result.root_pane.pane_id` from its JSON, then start the agent in it. For Claude Code, use `herdr agent start orchestrator --kind claude --pane <root-pane-id> -- --permission-mode bypassPermissions` (append `--model <m>` after the `--` if the operator has a policy). For Codex, use `herdr agent start orchestrator --kind codex --pane <root-pane-id> -- --dangerously-bypass-approvals-and-sandbox` (add `--model <m>` to specify the model). The unsandboxed flag is REQUIRED: codex's `workspace-write` sandbox keeps `.git` refs read-only, so a sandboxed orchestrator's `tickmarkr run` dies at integration-branch creation — do not downgrade it. Workers you never spawn — tickmarkr spawns its own visible worker panes. Auxiliary agents you do spawn (consultants, reviewers, scouts) follow the same forms: never launch a claude session in plan mode or default permission mode for autonomous work — both stall on per-command approval prompts nobody is watching; claude is always `--permission-mode bypassPermissions --settings '{"promptSuggestionEnabled":false}'`, and a read-only codex consultant may use `--sandbox read-only`. **That `--settings` pair is not cosmetic and it is not optional:** claude-code's AUTOSUGGEST renders context-plausible ghost text into an idle seat's prompt line that is BYTE-IDENTICAL to a typed draft in text-format reads (OBS-482), so a supervising tier cannot tell a seat's own unsent work from a rendering artifact without `agent read --format ansi`. Turning the suggester off at spawn removes the ambiguity at its source instead of paying for the discrimination at every read. Verified against the shipped binary: `claude --settings '{"promptSuggestionEnabled":false}' -p …` exits 0 with a real response, and the key appears in the binary's own settings schema. **For kimi, pass `-y`** (`herdr agent start <name> --kind kimi --pane <id> -- -y`) — the adapter already launches its own workers that way (`src/adapters/kimi.ts:204`), and a kimi seat spawned without it sits on an approval prompt having done nothing. **Herdr cannot see that state**: it reports a kimi pane as `agent_status: working` with `screen_detection_skipped: true` while the prompt is up, so the BLOCKED-STATE watcher below is blind on this vendor and the spawn flag is the ONLY control. Every vendor you spawn needs its auto-approve form named here; a vendor absent from this list is a seat that will hang.
+2. **Orchestrator**: Launch the orchestrator with your agent host. Spawning on current herdr is two-step — the one-shot `agent start --cwd` form was removed in the herdr CLI redesign and now fails with `unknown option` (OBS-138): first create the pane with `herdr tab create --workspace <ws> --cwd <repo> --label "ORCH · <version>"` and parse `result.root_pane.pane_id` from its JSON, then start the agent in it. For Claude Code, use `herdr agent start orchestrator --kind claude --pane <root-pane-id> -- --permission-mode bypassPermissions` (append `--model <m>` after the `--` if the operator has a policy). For Codex, use `herdr agent start orchestrator --kind codex --pane <root-pane-id> -- --dangerously-bypass-approvals-and-sandbox` (add `--model <m>` to specify the model). The unsandboxed flag is REQUIRED: codex's `workspace-write` sandbox keeps `.git` refs read-only, so a sandboxed orchestrator's `tickmarkr run` dies at integration-branch creation — do not downgrade it. Workers you never spawn — tickmarkr spawns its own visible worker panes. Auxiliary agents you do spawn (consultants, reviewers, scouts) follow the same forms: never launch a claude session in plan mode or default permission mode for autonomous work — both stall on per-command approval prompts nobody is watching; claude is always `--permission-mode bypassPermissions --settings '{"promptSuggestionEnabled":false}'`. **For a codex consultant, use `-a never --sandbox workspace-write` — NOT `--sandbox read-only`.** ⚠ **`--sandbox read-only` CONTRADICTS this skill's own completion protocol and will hang the seat.** Every seat you spawn is told to deliver an ARTIFACT ending in a terminal MARKER, because that is the only completion signal the artifact watcher can key on (`done` is turn end). A read-only sandbox cannot write that artifact, so codex blocks on `Would you like to make the following edits?` for its OWN report — and the report exists ONLY in the pending edit, so abandoning the prompt destroys the work rather than merely delaying it. Measured 2026-08-28: a consultant spawned `--sandbox read-only` finished a 14,604-byte verdict, sat blocked on the write, and the operator saw the prompt before the supervising tier did. `read-only` is correct ONLY for a seat that writes nothing at all — which, under the artifact+marker rule, is no seat this skill tells you to spawn. When the prompt does appear, answer **"Yes, and don't ask again for these files"** rather than plain yes: plain yes re-blocks on the next write of the same file. **That `--settings` pair is not cosmetic and it is not optional:** claude-code's AUTOSUGGEST renders context-plausible ghost text into an idle seat's prompt line that is BYTE-IDENTICAL to a typed draft in text-format reads (OBS-482), so a supervising tier cannot tell a seat's own unsent work from a rendering artifact without `agent read --format ansi`. Turning the suggester off at spawn removes the ambiguity at its source instead of paying for the discrimination at every read. Verified against the shipped binary: `claude --settings '{"promptSuggestionEnabled":false}' -p …` exits 0 with a real response, and the key appears in the binary's own settings schema. **For kimi, pass `-y`** (`herdr agent start <name> --kind kimi --pane <id> -- -y`) — the adapter already launches its own workers that way (`src/adapters/kimi.ts:204`), and a kimi seat spawned without it sits on an approval prompt having done nothing. **Herdr cannot see that state**: it reports a kimi pane as `agent_status: working` with `screen_detection_skipped: true` while the prompt is up, so the BLOCKED-STATE watcher below is blind on this vendor and the spawn flag is the ONLY control. Every vendor you spawn needs its auto-approve form named here; a vendor absent from this list is a seat that will hang.
 3. **Standing instructions travel as a brief FILE, never as pane text** — PTY input truncates at ~1024B and a
    truncated brief silently drops policy. Write the full brief to `<repo>/.tickmarkr/overseer/ORCH-BRIEF.md`
    (inside the tickmarkr state dir — already self-gitignored, no exclude step needed), then send one line:
@@ -1053,6 +1053,17 @@ twice.** They are mission-independent on purpose: nothing here names a task, a l
     concluded both forms were valid. The tell is unavailable unless the tool volunteers it. Corollary —
     an instrument that takes an input must be handed a DELIBERATELY BAD one before its clean runs are
     worth anything (rule 11 applied to tools, not just to gates).
+    ⚠ **AND THE COMMONEST WRONG INPUT IS A BASE REF: after the first merge, a task's diff against the
+    run's `baseRef` is NEVER that task's diff.** Workers branch from the INTEGRATION TIP, so once any task
+    has merged, `git diff baseRef..HEAD` in a later worktree reports that task PLUS every task merged
+    before it, and the number looks entirely plausible. Diff from the task's OWN base — the integration
+    commit it branched from — and say which base you used whenever you quote a size.
+    **Measured 2026-08-28 in one run, twice, in both directions.** A supervising seat quoted "712
+    insertions across 7 files" for a task whose real contribution was **300 across 2**; the surplus was two
+    other tasks' merged work. On the next task the same trap was **larger** — 920 across 11 versus a true
+    167 across 4 — and it was caught only because the other tier had just been burned by it. A scope
+    judgement, a cost claim, or a review-size argument built on the baseRef diff is measuring three tasks
+    and calling it one.
 14. **A unit is not a measurement.** A configured timeout is a KILL CEILING, not a duration — never compare
     it to a wall clock or quote it to an operator as an estimate.
 15. **Verify through the path that LOADS, not the path you edited.** Mirrored trees and symlinks mean your