tickmarkr 2.1.5 → 2.1.7

package/dist/cli/commands/beat.js

@@ -1,7 +1,7 @@
 import { mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { tickmarkrDir } from "../../graph/graph.js";
-import { SUPERVISION_BEAT_MS, SUPERVISION_STALE_MS, SUPERVISION_TIERS, beatSupervision, supervisionStandDownPath, } from "../../run/supervision.js";
+import { SUPERVISION_BEAT_MS, SUPERVISION_DEFAULT_THRESHOLD_PCT, SUPERVISION_STALE_MS, SUPERVISION_TIERS, beatSupervision, supervisionStandDownPath, } from "../../run/supervision.js";
 // SUP-04: the writer side of supervision, as a VERB. `beatSupervision` and `SUPERVISION_BEAT_MS` shipped
 // with exactly one in-repo caller — the daemon, on one tier — so `status` printed
 // `orchestrator ARMED / overseer ABSENT / watch ABSENT` while a real overseer worked the run: two thirds
@@ -18,16 +18,22 @@ import { SUPERVISION_BEAT_MS, SUPERVISION_STALE_MS, SUPERVISION_TIERS, beatSuper
 // reads UNREADABLE. Here the writes are unguarded: a failure leaves the process with a non-zero exit
 // and a message instead of a claim. The LOOP belongs to the caller, which is what makes the beat
 // evidence: stop calling it and the tier ages into STALE on its own.
+const VALUE_OPTIONS = ["--seat", "--arm-id", "--pct", "--threshold-pct"];
 export async function beat(argv, cwd = process.cwd()) {
     const standDown = argv.includes("--stand-down");
     const seat = seatOf(argv);
-    const named = argv.find((a, i) => !a.startsWith("--") && argv[i - 1] !== "--seat");
+    const pct = percentageOf(argv, "--pct");
+    const thresholdPct = percentageOf(argv, "--threshold-pct") ?? SUPERVISION_DEFAULT_THRESHOLD_PCT;
+    const armId = optionOf(argv, "--arm-id");
+    const named = argv.find((a, i) => !a.startsWith("--") && !VALUE_OPTIONS.includes(argv[i - 1] ?? ""));
     if (!isTier(named)) {
-        throw new Error(`usage: tickmarkr beat <${SUPERVISION_TIERS.join("|")}> --seat <identity> [--stand-down] — got ${named ? `\`${named}\`` : "no tier"}`);
+        throw new Error(`usage: tickmarkr beat <${SUPERVISION_TIERS.join("|")}> --seat <identity> ` +
+            `[--arm-id <identity> --pct <0..100> --threshold-pct <0..100>] [--stand-down] — ` +
+            `got ${named ? `\`${named}\`` : "no tier"}`);
     }
     // SUP-05: NO SEAT, NO BEAT — and the refusal comes before any write, so a refused invocation leaves
-    // the tier exactly as it found it. This verb is one-shot: the pid it would otherwise record has
-    // already exited by the time anyone reads the record, so tier + pid + instant is a beat nobody can
+    // the tier exactly as it found it. This verb is one-shot: the exitedWriterPid it records has
+    // already exited by the time anyone reads the record, so tier + writer + instant is a beat nobody can
     // attribute to a seat. Measured 2026-08-26: a consult seat ran the documented loop verbatim and the
     // board read that tier ARMED with no seat of that tier having armed anything, and a seatless ARMED
     // reads as coverage — worse than ABSENT, because ABSENT sends someone to look.
@@ -42,16 +48,35 @@ export async function beat(argv, cwd = process.cwd()) {
     // uncleared marker would render DISARMED while this verb claimed ARMED, so the removal is unguarded
     // too — `force` makes the ordinary "no marker" case a no-op, and anything else is a real failure.
     rmSync(supervisionStandDownPath(cwd, named), { force: true, recursive: true });
-    beatSupervision(cwd, named, seat);
+    beatSupervision(cwd, named, seat, pct === undefined ? undefined : { armId: armId ?? seat, pct, thresholdPct });
     return `${named} ARMED as ${seat} — beat again every ${SUPERVISION_BEAT_MS / 1_000}s; the tier reads STALE ${SUPERVISION_STALE_MS / 1_000}s after the last beat`;
 }
 /** `--seat <identity>` or `--seat=<identity>`; blank and missing are the same answer — none. */
 function seatOf(argv) {
-    const inline = argv.find((a) => a.startsWith("--seat="))?.slice("--seat=".length);
-    const spaced = argv[argv.indexOf("--seat") + 1];
-    const seat = (inline ?? (argv.includes("--seat") ? spaced : undefined))?.trim();
+    const seat = optionOf(argv, "--seat")?.trim();
     return seat && !seat.startsWith("--") ? seat : undefined;
 }
+/** A `--name value` or `--name=value` option, excluding a missing value or the next flag. */
+function optionOf(argv, name) {
+    const inline = argv.find((a) => a.startsWith(`${name}=`))?.slice(name.length + 1).trim();
+    const spaced = argv[argv.indexOf(name) + 1]?.trim();
+    const value = inline ?? (argv.includes(name) ? spaced : undefined);
+    return value && !value.startsWith("--") ? value : undefined;
+}
+function percentageOf(argv, name) {
+    const raw = optionOf(argv, name);
+    if (raw === undefined) {
+        if (argv.includes(name) || argv.some((a) => a.startsWith(`${name}=`))) {
+            throw new Error(`${name} needs a number from 0 through 100`);
+        }
+        return undefined;
+    }
+    const value = Number(raw);
+    if (!Number.isFinite(value) || value < 0 || value > 100) {
+        throw new Error(`${name} must be a number from 0 through 100`);
+    }
+    return value;
+}
 // Stand-down is a RECORDED act, not a silence: the marker tells a reader this watcher left on purpose,
 // so the tier reads DISARMED rather than ageing out as a death. Published atomically — written aside,
 // renamed over — because a torn marker is rejected by the reader, and a rejected stand-down reports a
@@ -63,7 +88,9 @@ function standDownTier(repoRoot, tier, seat) {
     mkdirSync(dirname(p), { recursive: true });
     // The marker names the seat for the same reason the beat does: "someone stood this tier down" is not
     // a hand-off anyone can act on, and on a seat tier the reader rejects an anonymous one outright.
-    writeFileSync(tmp, JSON.stringify({ tier, seat, pid: process.pid, disarmedAt: new Date().toISOString() }) + "\n");
+    writeFileSync(tmp, JSON.stringify({
+        tier, seat, exitedWriterPid: process.pid, disarmedAt: new Date().toISOString(),
+    }) + "\n");
     renameSync(tmp, p);
     return `${tier} DISARMED — ${seat} handed off; status reads it stood down, not dead`;
 }

package/dist/cli/commands/run.js

@@ -167,7 +167,7 @@ const railTone = (event, fallback) => {
     // `gate-result` is the one event whose data IS a gate result; every other row carrying a `gate`
     // names a gate without reporting one (a start, a reuse, a retry) and keeps its declared tone.
     if (event.event === "gate-result")
-        return GATE_OUTCOME_TONES[normalizeGateOutcome(event.data).kind] ?? fallback;
+        return GATE_OUTCOME_TONES[normalizeGateOutcome(event.data).kind];
     const verdict = event.data.pass ?? event.data.ok;
     return verdict === true ? "pass" : verdict === false ? "fail" : fallback;
 };
@@ -226,7 +226,24 @@ const railSalient = (data) => RAIL_SALIENT.flatMap(({ key, render }) => {
  * This is one detail vocabulary stated twice, so `brand-surfaces.test.ts` pins the two against each
  * other over the whole event corpus: the pipe's bytes must equal event/taskId/THIS detail put through
  * the formatter's legacy squeeze-and-slice. A ladder that drifts fails there rather than in a tab.
+ * Gate-result verdict words are the deliberate exception: the pipe is byte-frozen, while the TTY rail
+ * names the normalized outcome so a held selected-test screen is not narrated as a pass.
  */
+const gateResultDetail = (data) => {
+    if (typeof data.gate !== "string")
+        return undefined;
+    switch (normalizeGateOutcome(data).kind) {
+        case "passed":
+            return `${data.gate} passed`;
+        case "failed":
+            return `${data.gate} failed`;
+        case "held":
+            // The kind is already normalized; the selected-test list only chooses this surface noun.
+            return Array.isArray(data.selectedTests) ? `${data.gate} selected-test screen` : `${data.gate} held`;
+        default:
+            return data.gate;
+    }
+};
 const formatterDetail = ({ event, data }) => {
     const assignment = data.assignment;
     const direct = [data.summary, data.reason, data.error, data.step, data.action, data.lint, data.branch, data.from]
@@ -240,7 +257,9 @@ const formatterDetail = ({ event, data }) => {
         }
         if (event === "tip-verify")
             return `${data.gate} passed`;
-        return `${data.gate}${data.pass === true ? " passed" : data.pass === false ? " failed" : ""}`;
+        if (event === "gate-result")
+            return gateResultDetail(data);
+        return `${data.gate}`;
     }
     if (typeof data.code === "number")
         return `exit ${data.code}`;

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,200 @@
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { stateDirName } from "../../graph/graph.js";
+import { Journal } from "../../run/journal.js";
+import { normalizeGateOutcome } from "../../run/outcome.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 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);
+            }
+            const outcome = normalizeGateOutcome(event.data);
+            if (outcome.kind === "infra")
+                channel.infraReds += 1;
+            else if (outcome.kind === "failed")
+                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,12 +7,12 @@ 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";
 import { normalizeStallSnapshot } from "../../run/stall.js";
-import { armSupervision, readSupervision, supervisionText } from "../../run/supervision.js";
+import { armWatchSupervision, readSupervision, supervisionText } from "../../run/supervision.js";
 import { deriveRunCockpitData, } from "../../tui/cockpit/derive.js";
 import { COCKPIT_COLUMN_FLOOR } from "../../tui/cockpit/layout.js";
 import { cellWidth, fitCells, wrapCells } from "../../tui/cockpit/width.js";
@@ -109,6 +109,15 @@ const ASCII_SPINNER = ["|", "/", "-", "\\"];
 const SAVE_TERMINAL_TITLE = "\x1b[22;0t";
 const RESTORE_TERMINAL_TITLE = "\x1b[23;0t";
 const decisionEvidence = (stateDir, runId, sequence) => `${stateDir}/runs/${runId}/journal.jsonl#L${sequence}`;
+const DECISION_GATE_VERDICTS = {
+    passed: "passed",
+    failed: "failed",
+    skipped: "skipped",
+    declined: "skipped",
+    held: "unknown",
+    unavailable: "unknown",
+    infra: "unknown",
+};
 // v1.79 T4: a deterministic JSONL projection over journal truth. Sequence/evidence come from the
 // append-only line position, timestamps and claims come from the row, and no watcher-local clock or
 // filesystem write participates. Re-reading the same bytes therefore returns the same event bytes.
@@ -126,13 +135,7 @@ export const decisionEventsFromJournal = (events, runId, stateDir = ".tickmarkr"
         return [{ ...base, type: "phase-change", tier: "routine", phase: event.data.phase }];
     }
     if (event.event === "gate-result" && typeof event.data.gate === "string") {
-        const verdict = event.data.skipped === true
-            ? "skipped"
-            : event.data.pass === true
-                ? "passed"
-                : event.data.pass === false
-                    ? "failed"
-                    : "unknown";
+        const verdict = DECISION_GATE_VERDICTS[normalizeGateOutcome(event.data).kind];
         return [{
                 ...base,
                 type: "gate-verdict",
@@ -381,6 +384,13 @@ export const gateBox = (state, unicode) => {
     return state === "pass" ? "[x]" : state === "fail" ? "[!]" : state === "skip" ? "." : "[ ]";
 };
 export const defaultGateStates = (task) => GATE_NAMES.map((gate) => task.gates.includes(gate) ? "open" : "skip");
+const GATE_OUTCOME_STATES = {
+    // The board state is a rendering vocabulary over the normalized outcome, not another field reader.
+    passed: "pass",
+    failed: "fail",
+    skipped: "skip",
+    declined: "skip",
+};
 const gateSnapshot = (task, events, rehashAt) => {
     const outcomes = new Map();
     const start = attemptStartIdx(events, task.id);
@@ -389,12 +399,9 @@ const gateSnapshot = (task, events, rehashAt) => {
             const e = events[eventIndex];
             if (e.taskId !== task.id || e.event !== "gate-result" || typeof e.data.gate !== "string")
                 continue;
-            if (e.data.skipped === true)
-                outcomes.set(e.data.gate, { state: "skip", eventIndex });
-            else if (e.data.pass === true)
-                outcomes.set(e.data.gate, { state: "pass", eventIndex });
-            else if (e.data.pass === false)
-                outcomes.set(e.data.gate, { state: "fail", eventIndex });
+            const state = GATE_OUTCOME_STATES[normalizeGateOutcome(e.data).kind];
+            if (state)
+                outcomes.set(e.data.gate, { state, eventIndex });
         }
     }
     return {
@@ -519,7 +526,7 @@ const foldTaskEffort = (tasks, events) => {
             task.dispatches += 1;
         else if (event.event === "gate-result" && event.data.gate === "review"
             && event.data.replayMeasurement !== true
-            && REVIEW_VERDICTS.has(normalizeGateOutcome(event.data.outcome ?? event.data).kind))
+            && REVIEW_VERDICTS.has(normalizeGateOutcome(event.data).kind))
             task.reviews += 1;
         else if (event.event === "task-human")
             task.parks += 1;
@@ -979,6 +986,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 +1033,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 +1042,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 +1235,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 +1251,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
             taskSection,
             "",
             ...tableRows(),
+            ...recoverySection,
             gatesLegend,
             "",
             rule(boardColumns),
@@ -1383,7 +1415,7 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
     // it INVERTS it: armSupervision's interval outlives the board in any host that outlives one board, so
     // a dead board keeps writing and reads ARMED. That is the over-claiming direction, the one an operator
     // acts on, and the one this instrument exists to close.
-    const armed = bounded ? undefined : armSupervision(cwd, "watch", opts.supervisionBeatMs);
+    const armed = bounded ? undefined : armWatchSupervision(cwd, opts.supervisionBeatMs);
     let titleSaved = false;
     const restoreTitle = () => {
         if (!titleSaved)

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/compile/index.d.ts

@@ -10,6 +10,6 @@ export type PlanIR = {
     tasks: RunGraph["tasks"];
 };
 export type PlanFinalizationHook = (plan: PlanIR) => PlanIR;
-export declare function finalizePlan(plan: PlanIR, src: string): RunGraph;
+export declare function finalizePlan(plan: PlanIR, src: string, repoRoot?: string): RunGraph;
 export declare function compileSource(src: string, type?: SourceType, root?: string, beforeFinalize?: PlanFinalizationHook): RunGraph;
 export {};

package/dist/compile/index.js

@@ -2,6 +2,7 @@ import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { validateGraph } from "../graph/schema.js";
 import { taskUnitContractErrors } from "./collateral.js";
+import { ownershipFindings, renderOwnershipFinding } from "./ownership.js";
 import { CompileError } from "./common.js";
 import { compileGsd, isGsdPhaseDir } from "./gsd.js";
 import { compileNative, TICKMARKR_NATIVE_MARKER } from "./native.js";
@@ -40,8 +41,8 @@ function enforceTaskUnitContract(g, src) {
     }
     return g;
 }
-export function finalizePlan(plan, src) {
-    const graph = validateGraph({
+export function finalizePlan(plan, src, repoRoot) {
+    const graph = enforceTaskUnitContract(validateGraph({
         version: plan.version,
         ...(plan.mode !== undefined ? { mode: plan.mode } : {}),
         spec: {
@@ -51,8 +52,16 @@ export function finalizePlan(plan, src) {
             ...(plan.base !== undefined ? { base: plan.base } : {}),
         },
         tasks: plan.tasks,
-    });
-    return enforceTaskUnitContract(graph, src);
+    }), src);
+    // overseer-217: report-only in 2.1.7. The 2.1.8 removal condition is one real authored-graph run
+    // plus a measured false-positive rate for the conventional source-name → test-name mapping.
+    // Until then this warning MUST NOT become a compile abort: a heuristic cannot deadlock compile.
+    if (repoRoot) {
+        for (const finding of ownershipFindings(graph.tasks, repoRoot)) {
+            console.warn(renderOwnershipFinding(finding));
+        }
+    }
+    return graph;
 }
 function compilePlan(src, type, root) {
     const kind = type ?? detect(src);
@@ -75,5 +84,5 @@ function compilePlan(src, type, root) {
     };
 }
 export function compileSource(src, type, root, beforeFinalize = (plan) => plan) {
-    return finalizePlan(beforeFinalize(compilePlan(src, type, root)), src);
+    return finalizePlan(beforeFinalize(compilePlan(src, type, root)), src, root);
 }

package/dist/compile/ownership.d.ts

@@ -0,0 +1,25 @@
+import type { Task } from "../graph/schema.js";
+export type OwnershipFinding = {
+    code: "unowned-test";
+    test: string;
+    taskIds: string[];
+    detail: string;
+} | {
+    code: "test-path-outside-allowlist";
+    taskId: string;
+    test: string;
+    path: string;
+    detail: string;
+} | {
+    code: "unordered-context-write";
+    taskId: string;
+    ownerTaskId: string;
+    path: string;
+    detail: string;
+};
+/**
+ * Advisory cross-task ownership check. Findings are data: callers may report them, but this checker
+ * never throws and never changes the graph.
+ */
+export declare function ownershipFindings(tasks: readonly Task[], repoRoot: string): OwnershipFinding[];
+export declare function renderOwnershipFinding(finding: OwnershipFinding): string;