tickmarkr 2.1.2 → 2.1.3

package/dist/adapters/claude-code.js

@@ -209,7 +209,7 @@ export const claudeCode = {
     channels: (cfg) => channelsFromConfig("claude-code", cfg),
     // v1.65 T3: every flag the command builders below hardcode — doctor checks `claude --help` still
     // lists each (all present on claude 2.x, verified 2026-07-22). Advisory only, never routing.
-    hardcodedFlags: { binary: "claude", flags: ["-p", "--model", "--permission-mode", "--strict-mcp-config", "--mcp-config", "--output-format", "-r"] },
+    hardcodedFlags: { binary: "claude", flags: ["-p", "--model", "--permission-mode", "--strict-mcp-config", "--mcp-config", "--output-format", "-r", "--prompt-suggestions"] },
     // --strict-mcp-config --mcp-config '{"mcpServers":{}}': pin the MCP surface to empty so fresh-worktree
     // workers/gates don't load project .mcp.json servers (herdr scrapes dialogs as idle — v1.4 incident,
     // memory tickmarkr-worker-mcp-dialog-stall). Live-verified 2026-07-10 on claude 2.1.205 (operator check):
@@ -223,10 +223,25 @@ export const claudeCode = {
     // HYG-03 / OBS-137: the residual first-entry dialog is workspace trust, not MCP config loading.
     // Claude's only store is global last-writer-wins ~/.claude.json, so tickmarkr still does not seed it;
     // the daemon safely answers only the exact adapter-declared dialog once per slot.
-    interactiveCommand: (promptFile, model) => `claude --model ${shq(model)} --strict-mcp-config --mcp-config '{"mcpServers":{}}' --permission-mode bypassPermissions "$(cat ${shq(promptFile)})"`,
+    //
+    // v2.1.3 T7 --prompt-suggestions false: claude paints a PREDICTED next prompt into the editor after
+    // a turn. On a pane it is pixel-identical to a seat's own unsubmitted draft, so every occupancy
+    // reader downstream — the input-box occupiedMatch above, the stall watchdog that sweeps for a
+    // parked turn — reads the vendor's ghost text as work in progress and waits out its window on a
+    // worker that is idle. Suppressed at the SOURCE instead: the two builders that seed a real terminal
+    // are exactly these (interactive, resume); the -p builder has no editor to paint into and is out of
+    // scope. Live-checked against claude 2.1.246: the flag parses and `false` is an allowed choice
+    // ("Allowed choices are true, false, 1, 0, yes, no, on, off").
+    // Placement is NOT free: --mcp-config above is variadic and eats the next positional (2026-07-10
+    // live check ate the prompt), and --prompt-suggestions takes an OPTIONAL value — appended directly
+    // before the prompt it would swallow it the same way. So the setting's value is always followed by
+    // another flag, never by the prompt positional.
+    interactiveCommand: (promptFile, model) => `claude --model ${shq(model)} --strict-mcp-config --mcp-config '{"mcpServers":{}}' --prompt-suggestions false --permission-mode bypassPermissions "$(cat ${shq(promptFile)})"`,
     trustDialog: CLAUDE_TRUST_DIALOG,
     inputBox: CLAUDE_INPUT_BOX,
-    resumeCommand: (sessionId, promptFile, model) => `claude -r ${shq(sessionId)} --model ${shq(model)} --strict-mcp-config --mcp-config '{"mcpServers":{}}' --permission-mode bypassPermissions "$(cat ${shq(promptFile)})"`,
+    // A resumed attempt lands in the same painted editor, so it carries the same ghost-text suppression
+    // and the same value-then-flag placement.
+    resumeCommand: (sessionId, promptFile, model) => `claude -r ${shq(sessionId)} --model ${shq(model)} --strict-mcp-config --mcp-config '{"mcpServers":{}}' --prompt-suggestions false --permission-mode bypassPermissions "$(cat ${shq(promptFile)})"`,
     invoke(task, _cwd, a, ctx) {
         return { command: this.headlessCommand(ctx.promptFile, a.model) };
     },

package/dist/adapters/pi.d.ts

@@ -1,3 +1,9 @@
 import { type WorkerAdapter } from "./types.js";
 export declare function parsePiModels(raw: string): string[];
+export interface ServedModelDrift {
+    pinned: string;
+    served: string;
+}
+export declare function readPiServedModels(): ServedModelDrift[];
+export declare function servedModelNote(drifts?: ServedModelDrift[]): string;
 export declare const pi: WorkerAdapter;

package/dist/adapters/pi.js

@@ -32,6 +32,92 @@ export function parsePiModels(raw) {
         .map(([provider, model]) => `${provider}/${model}`)
         .filter((id) => MODEL_ID_RE.test(id));
 }
+// Newest-first by mtime, capped — mtime picks WHICH files to scan, never a record's cursor.
+// Shared by collectUsage (spend) and readPiServedModels (v2.1.3 T7): same store, same bounds.
+function sessionFileStats(dir) {
+    return readdirSync(dir)
+        .filter((f) => f.endsWith(".jsonl"))
+        .map((f) => {
+        const path = join(dir, f);
+        try {
+            return { f: path, m: statSync(path).mtimeMs };
+        }
+        catch {
+            return undefined; // a stat failure just drops that file
+        }
+    })
+        .filter((x) => x !== undefined);
+}
+function newestSessionFiles(entries) {
+    return [...entries].sort((a, b) => b.m - a.m).slice(0, MAX_SESSION_FILES).map((x) => x.f);
+}
+// ponytail: three distinct pairs is the note's ceiling — raise it if a real store ever shows more.
+const MAX_DRIFT_PAIRS = 3;
+export function readPiServedModels() {
+    const root = join(homedir(), ".pi", "agent", "sessions");
+    let files;
+    try {
+        files = newestSessionFiles(readdirSync(root).flatMap((slug) => {
+            try {
+                return sessionFileStats(join(root, slug));
+            }
+            catch {
+                return []; // not a directory / unreadable ⇒ skip
+            }
+        }));
+    }
+    catch {
+        return []; // no store ⇒ nothing to report
+    }
+    const out = [];
+    const seen = new Set();
+    for (const file of files) {
+        let text;
+        try {
+            text = readFileSync(file, "utf8").slice(0, MAX_SESSION_BYTES);
+        }
+        catch {
+            continue;
+        }
+        for (const line of text.split("\n")) {
+            if (!line.trim())
+                continue;
+            let recRaw;
+            try {
+                recRaw = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (recRaw === null || typeof recRaw !== "object" || Array.isArray(recRaw))
+                continue;
+            const rec = recRaw;
+            if (rec.type !== "message" || rec.message?.role !== "assistant")
+                continue;
+            const pinned = rec.message?.model;
+            const served = rec.message?.responseModel;
+            // absent responseModel === the two agree. Never a mismatch, never an alarm.
+            if (typeof served !== "string" || typeof pinned !== "string" || served === pinned)
+                continue;
+            if (!MODEL_ID_RE.test(served) || !MODEL_ID_RE.test(pinned))
+                continue;
+            const key = `${pinned}\u0000${served}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            out.push({ pinned, served });
+            if (out.length >= MAX_DRIFT_PAIRS)
+                return out;
+        }
+    }
+    return out;
+}
+// The probe's note clause, or "" when the store reports no discrepancy at all.
+export function servedModelNote(drifts = readPiServedModels()) {
+    if (drifts.length === 0)
+        return "";
+    return `served-model drift: ${drifts.map((d) => `pinned ${d.pinned} served ${d.served}`).join(", ")}`;
+}
 export const pi = {
     id: "pi",
     // FLEET-04: cross-vendor review honesty — GLM's provider (pi's own label is "zai"; either is
@@ -42,10 +128,17 @@ export const pi = {
         const h = probeVersion("pi");
         if (!h.installed)
             return h;
+        // The store is local and independently useful: preserve its advisory even when the network/auth
+        // capability call below fails. A failed model listing must not erase evidence of a substitution.
+        const drift = servedModelNote();
         const r = spawnSync("pi", ["--list-models"], { encoding: "utf8", timeout: 15000 });
-        if (r.error || r.status !== 0)
-            return h;
-        return { ...h, servable: parsePiModels(r.stdout || ""), note: "auth verified via pi --list-models (free; auth-filtered by pi)" };
+        if (r.error || r.status !== 0) {
+            return drift ? { ...h, note: `${h.note ? `${h.note}; ` : ""}${drift}` } : h;
+        }
+        // v2.1.3 T7: the probe is the production caller that already reads this store, and doctor/fleet
+        // already render its note — so the served-model discrepancy is reported where it is already read.
+        const note = `auth verified via pi --list-models (free; auth-filtered by pi)${drift ? `; ${drift}` : ""}`;
+        return { ...h, servable: parsePiModels(r.stdout || ""), note };
     },
     channels: (cfg) => channelsFromConfig("pi", cfg),
     // v1.65 T3: every flag the command builders below hardcode — verified in `pi --help` 2026-07-22.
@@ -84,25 +177,13 @@ export const pi = {
             const real = realpathSync(cwd);
             const slug = "-" + real.replaceAll("/", "-") + "--";
             const dir = join(homedir(), ".pi", "agent", "sessions", slug);
-            const files = readdirSync(dir)
-                .filter((f) => f.endsWith(".jsonl"))
-                .map((f) => {
-                try {
-                    return { f, m: statSync(join(dir, f)).mtimeMs };
-                }
-                catch {
-                    return undefined;
-                }
-            })
-                .filter((x) => x !== undefined)
-                .sort((a, b) => b.m - a.m)
-                .slice(0, MAX_SESSION_FILES);
+            const files = newestSessionFiles(sessionFileStats(dir));
             let input = 0, output = 0, kept = false;
             let cacheRead, cacheWrite;
-            for (const { f } of files) {
+            for (const f of files) {
                 let text;
                 try {
-                    text = readFileSync(join(dir, f), "utf8").slice(0, MAX_SESSION_BYTES);
+                    text = readFileSync(f, "utf8").slice(0, MAX_SESSION_BYTES);
                 }
                 catch {
                     continue;

package/dist/cli/commands/beat.js

@@ -20,31 +20,51 @@ import { SUPERVISION_BEAT_MS, SUPERVISION_STALE_MS, SUPERVISION_TIERS, beatSuper
 // evidence: stop calling it and the tier ages into STALE on its own.
 export async function beat(argv, cwd = process.cwd()) {
     const standDown = argv.includes("--stand-down");
-    const named = argv.find((a) => !a.startsWith("--"));
+    const seat = seatOf(argv);
+    const named = argv.find((a, i) => !a.startsWith("--") && argv[i - 1] !== "--seat");
     if (!isTier(named)) {
-        throw new Error(`usage: tickmarkr beat <${SUPERVISION_TIERS.join("|")}> [--stand-down] — got ${named ? `\`${named}\`` : "no tier"}`);
+        throw new Error(`usage: tickmarkr beat <${SUPERVISION_TIERS.join("|")}> --seat <identity> [--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
+    // 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.
+    if (!seat) {
+        throw new Error(`${named} needs --seat <identity> — a beat that names no seat arms a tier nobody occupies` +
+            " (pass the seat's own pane id or agent name)");
     }
     if (standDown)
-        return standDownTier(cwd, named);
+        return standDownTier(cwd, named, seat);
     // Clear a stand-down marker left by an earlier session BEFORE beating: a valid marker outranks every
     // beat that does not strictly follow it, and two writes landing in the same millisecond do not. An
     // uncleared marker would render DISARMED while this verb claimed ARMED, so the removal is unguarded
     // too — `force` makes the ordinary "no marker" case a no-op, and anything else is a real failure.
     rmSync(supervisionStandDownPath(cwd, named), { force: true, recursive: true });
-    beatSupervision(cwd, named);
-    return `${named} ARMED — beat again every ${SUPERVISION_BEAT_MS / 1_000}s; the tier reads STALE ${SUPERVISION_STALE_MS / 1_000}s after the last beat`;
+    beatSupervision(cwd, named, seat);
+    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();
+    return seat && !seat.startsWith("--") ? seat : undefined;
 }
 // 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
 // deliberate hand-off as a death.
-function standDownTier(repoRoot, tier) {
+function standDownTier(repoRoot, tier, seat) {
     tickmarkrDir(repoRoot); // the write path DOES create — markers land inside the gitignored state dir
     const p = supervisionStandDownPath(repoRoot, tier);
     const tmp = `${p}.${process.pid}.tmp`;
     mkdirSync(dirname(p), { recursive: true });
-    writeFileSync(tmp, JSON.stringify({ tier, pid: process.pid, disarmedAt: new Date().toISOString() }) + "\n");
+    // 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");
     renameSync(tmp, p);
-    return `${tier} DISARMED — hand-off recorded; status reads it stood down, not dead`;
+    return `${tier} DISARMED — ${seat} handed off; status reads it stood down, not dead`;
 }
 const isTier = (v) => SUPERVISION_TIERS.includes(v ?? "");

package/dist/cli/commands/init.js

@@ -109,7 +109,7 @@ Before \`tickmarkr compile\` or \`tickmarkr run\`: run \`tickmarkr version\`, re
 
 ### Tip-verify-before-green
 
-A run is green only when the run-end event exists in the journal AND tip verify is not "failed". Never report green to the operator, tab titles, or records until both hold.
+A run is green only when ALL of these hold: the run-end event exists in the journal, tip verify is not "failed", AND the run-end summary's \`failed\`, \`human\`, \`blocked\` and \`pending\` buckets are every one of them empty. The shorter "run-end plus tip verify" form is NOT sufficient: a run ending \`done=[T1,T3,T4] human=[T2] tipVerify=passed\` is a closed PARTIAL run — three of four delivered, one parked — and calling it green is how a park becomes invisible. Never report green to the operator, tab titles, or records until every clause holds; when one does not, name the bucket that is not empty.
 
 ### Verified handoffs
 
@@ -203,6 +203,24 @@ function skillDrift(cwd) {
 }
 // Name what drifted. "stale" alone sends the reader to diff three directories by hand, and the file that
 // matters is usually the one they never knew shipped.
+// The GENERATED GUIDANCE BLOCK goes stale by exactly the shape skillDrift exists for: the package
+// moves, the rendered copy does not, and nothing in the repo changes to hint at it. Worse than a skill,
+// because a doc the host reads as law can be gitignored — this project's own AGENTS.md kept two
+// superseded preflight rules (patch-version drift tolerated, a machine-wide process match required)
+// through the very release that fixed the tracked copy, and a consultation was launched under the stale
+// text with nobody able to see it. Same rule as skillDrift: a doc that was never written is not drift.
+const docsDrift = (cwd) => hostTargets(cwd).map(({ docPath }) => docPath).filter((docPath) => {
+    if (!existsSync(docPath))
+        return false;
+    const current = readFileSync(docPath, "utf8");
+    const begin = current.indexOf(DOCS_BEGIN);
+    if (begin < 0)
+        return false; // no block installed here — --docs writes one, that is not drift
+    const end = current.indexOf(DOCS_END, begin);
+    if (end < 0)
+        return true; // a truncated block is stale by definition
+    return current.slice(begin, end + DOCS_END.length) !== AGENT_DOCS.trimEnd();
+});
 const describeDrift = (d) => [
     d.missing.length ? `missing ${d.missing.join(", ")}` : "",
     d.modified.length ? `modified ${d.modified.join(", ")}` : "",
@@ -361,6 +379,15 @@ export async function init(argv, cwd = process.cwd(), io = {}) {
             notes.push(`stale ${join(d.dir, "SKILL.md")} — ${describeDrift(d)}; run tickmarkr init --agent --force to refresh it`);
         }
     }
+    // Same reasoning, one layer up — and the refresh command is `--agent --force`, the same one the skill
+    // note names. `--docs` governs only the APPEND path for a repo with no block yet; replacing an existing
+    // block is gated on force (see the marked-region branch in installAgentFiles). Naming `--docs` here
+    // would send the reader to a flag that silently does nothing for the case they are in.
+    if (!(values.agent && values.force)) {
+        for (const docPath of docsDrift(cwd)) {
+            notes.push(`stale ${docPath} — its tickmarkr guidance block does not match this version; run tickmarkr init --agent --force to refresh it`);
+        }
+    }
     const input = io.input ?? process.stdin;
     const output = io.output ?? process.stdout;
     const interactive = input.isTTY === true && output.isTTY === true && !(values.yes ?? false);

package/dist/cli/commands/status.js

@@ -8,6 +8,7 @@ import { blockedTasks, graphDefinitionHash, loadGraph, stateDirName } from "../.
 import { GATE_NAMES } from "../../graph/schema.js";
 import { foldActivity } from "../../run/activity.js";
 import { Journal, engagementComparable, isQualityFailureParkKind, recordedTaskFailureKind, runHasEnded, } 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";
@@ -617,6 +618,12 @@ const daemonPid = (events) => {
     }
     return undefined;
 };
+const daemonLiveness = (events) => {
+    const pid = daemonPid(events);
+    if (pid === undefined)
+        return { state: "unknown" };
+    return { state: isPidLive(pid) ? "alive" : "dead", pid };
+};
 const terminalFailureCause = (events) => {
     for (let i = events.length - 1; i >= 0; i--) {
         const e = events[i];
@@ -792,27 +799,19 @@ const keepPanesSetting = (cwd) => {
         return DEFAULT_CONFIG.visibility.keepPanes;
     }
 };
-const liveness = (events, now = Date.now()) => {
+const liveness = (events, daemon, now = Date.now()) => {
     const last = events.at(-1);
     if (!last)
         return "last event unknown · daemon pid unknown";
     const age = fmtAge(now - Date.parse(last.ts));
-    const pid = daemonPid(events);
     const cause = terminalFailureCause(events);
-    if (pid === undefined)
+    if (daemon.state === "unknown")
         return `last event ${age} ago · daemon pid unknown${cause ? ` · ${cause}` : ""}`;
     // a dead pid after run-end is a clean exit, not a crash — "dead" is only alarming (red) while
     // the run is still incomplete (operator's crash indicator)
     const ended = events.some((e) => e.event === "run-end");
-    let state;
-    try {
-        process.kill(pid, 0);
-        state = "alive";
-    } // no throw ⇒ alive
-    catch (k) {
-        state = k.code === "ESRCH" ? (ended ? "finished" : "dead") : "alive";
-    } // EPERM ⇒ alive
-    return `last event ${age} ago · daemon pid ${pid} ${state}${cause ? ` · ${cause}` : ""}`;
+    const state = daemon.state === "alive" ? "alive" : ended ? "finished" : "dead";
+    return `last event ${age} ago · daemon pid ${daemon.pid} ${state}${cause ? ` · ${cause}` : ""}`;
 };
 // Resume's shared comparator remains the fail-closed baseline. Status may additionally accept the
 // daemon's audited graph-rehash release, but only when its `from` names that baseline identity (or
@@ -899,6 +898,9 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
     const record = readRunRecord(cwd, g, namedRunId);
     const runId = record?.runId;
     const events = record?.events ?? [];
+    // The header and every live-phase consumer share this exact process reading. Proved death retires
+    // stale phase markers; unknown identity deliberately does not, preserving pre-identity journals.
+    const daemon = daemonLiveness(events);
     const comparable = record?.comparable ?? false;
     const rehashAt = record?.rehashAt;
     const assignments = new Map();
@@ -972,7 +974,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
         ? workerPaneLocators(events, runId, keepPanesSetting(cwd))
         : new Map();
     const taskIds = new Set(g.tasks.map((task) => task.id));
-    const phases = comparable ? livePhases(events) : new Map();
+    const phases = comparable && daemon.state !== "dead" ? livePhases(events) : new Map();
     for (const taskId of phases.keys())
         if (!taskIds.has(taskId))
             phases.delete(taskId);
@@ -1022,7 +1024,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
         });
         const zone = journalRowsOnly ? `${divider}zone ${localZoneLabel(zoneReference)}` : "";
         const header = runId
-            ? `tickmarkr status${divider}run ${runId}${zone}${supersededBy ? `${divider}superseded by ${supersededBy}` : ""}${!comparable ? `${divider}${NOT_COMPARABLE_NOTICE}` : ""}${divider}${liveness(events, now).replaceAll(" · ", divider)}${verify ? `${divider}${verify}` : ""}${divider}${tipPhase ? `${done}/${total} tasks done${divider}run not verified` : `${done}/${total} done`}`
+            ? `tickmarkr status${divider}run ${runId}${zone}${supersededBy ? `${divider}superseded by ${supersededBy}` : ""}${!comparable ? `${divider}${NOT_COMPARABLE_NOTICE}` : ""}${divider}${liveness(events, daemon, now).replaceAll(" · ", divider)}${verify ? `${divider}${verify}` : ""}${divider}${tipPhase ? `${done}/${total} tasks done${divider}run not verified` : `${done}/${total} done`}`
             : `tickmarkr status${zone}${divider}no runs yet${divider}${done}/${total} done`;
         const legendLine = `  gates: ${GATE_NAMES.map((gate) => `${GATE_KEYS[gate]} ${gate}`).join(divider)}`;
         return {
@@ -1046,7 +1048,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
     const tally = tipPhase
         ? `${progressTone(`${progressGlyph} ${done}/${total} tasks done`)}${dot}${progressTone("run not verified")}`
         : done === total && total > 0 ? ok(`${done}/${total} done`) : information(`${done}/${total} done`);
-    const live = liveness(events, now)
+    const live = liveness(events, daemon, now)
         .replace(/\bdead\b/u, fail("dead"))
         .replace(/\bfinished\b/u, dim("finished"))
         .replace(/\balive\b/u, running("alive"))

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|overseer|watch (--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  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

@@ -43,7 +43,7 @@ usage: tickmarkr <command>
   profile       show learned routing profile (profile reset = forget history via cursor, keeps telemetry)
   ui            open the Fleet Studio TUI (full-screen tabbed cockpit)
   unlock        remove a stale/garbage run lock (refuses if the holder is alive)
-  beat <tier>   record one supervision beat for orchestrator|overseer|watch (--stand-down to hand off); a supervising seat's own watcher loop calls it, and status reads the tier STALE once the beats stop
+  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
   approve <id> <task>  release a park (--uphold sides with the reviewer and funds a fixed attempt; --by <name> --reason <text>); takes effect on resume`;
 // pure, testable dispatcher: resolves a command, forwards argv, shapes the result — no side effects.
 // unknown/missing cmd → USAGE (exit 1 if a cmd was typed, 0 for bare `tickmarkr`); a handler throw becomes

package/dist/gates/baseline.d.ts

@@ -12,6 +12,12 @@ export interface BaselineCommand {
     missingCommand?: boolean;
     /** What this command actually took at capture, on a pristine tree. Absent in pre-v1.90 baselines. */
     durationMs?: number;
+    /** Sum of the per-file durations named by the runner; null when its output names none. */
+    fileDurationSumMs?: number | null;
+    /** fileDurationSumMs / durationMs — average implied file concurrency, not a configured fork count. */
+    impliedParallelism?: number | null;
+    /** The slowest per-file entry named by the runner; null when per-file timing is unavailable. */
+    longestFile?: BaselineFileDuration | null;
     /** The ceiling that measurement implies, persisted so every later battery uses the same number. */
     ceilingMs?: number;
     /**
@@ -20,6 +26,10 @@ export interface BaselineCommand {
      */
     infra?: true;
 }
+export interface BaselineFileDuration {
+    file: string;
+    durationMs: number;
+}
 export interface Baseline {
     commands: Record<string, BaselineCommand>;
     warnings?: BaselineWarning[];

package/dist/gates/baseline.js

@@ -24,6 +24,12 @@ const SUMMARY_FAIL_RE = /^\s*(?:Tests?\s+(?:Files?\s+)?(?:\d+|#)\s+failed|#\s+fa
 const ERROR_ANCHOR_RE = /^\s*(?:Error|[A-Za-z_$][\w$]*Error):\s+\S/;
 const TSC_ERROR_RE = /^\s*\S.*\((?:\d+|#),(?:\d+|#)\):\s+error\s+[A-Z]+(?:\d+|#):/i; // tsc
 const LINTER_ERROR_RE = /^\s*(?:\d+|#):(?:\d+|#)\s+error\s+\S/; // eslint stylish
+// T5: package.json selecting oxlint's stylish format is this repository's local remedy because the
+// existing LINTER_ERROR_RE already reads it. PATH_FIRST_LINTER_ERROR_RE is the shipped fix: it reads
+// the default `path:line:column: error …` form for every user without requiring their script to change.
+// Keep the path at line start — accepting a position mid-sentence turns ordinary runner prose into a
+// manufactured fresh failure.
+const PATH_FIRST_LINTER_ERROR_RE = /^\s*\S+:(?:\d+|#):(?:\d+|#):\s+error\b(?:\s+\S)?/;
 // The failure shapes non-Vitest runners name their tests with: pytest's short summary
 // (`FAILED tests/t.py::test_x - AssertionError`, `ERROR tests/t.py::fixture`), go test
 // (`--- FAIL: TestFoo (0.00s)`), TAP / node:test (`not ok 1 - name`, whose summary line lands in
@@ -97,7 +103,7 @@ const namesFailureEitherForm = (l) => {
     return stripped !== undefined && namesFailure(stripped);
 };
 const isFailureShaped = (l) => namesFailure(l) || SUMMARY_FAIL_RE.test(l) || ERROR_ANCHOR_RE.test(l)
-    || TSC_ERROR_RE.test(l) || LINTER_ERROR_RE.test(l) || X_GLYPH_FAIL_RE.test(l);
+    || TSC_ERROR_RE.test(l) || LINTER_ERROR_RE.test(l) || PATH_FIRST_LINTER_ERROR_RE.test(l) || X_GLYPH_FAIL_RE.test(l);
 const VOCAB_RE = /\b(?:error|fail(?:ed|ure|ing)?)\b/i;
 // T9 — the infra/regression discriminator. A runner that died because the MACHINE ran out of
 // processes, file descriptors or memory never finished asking the question, so its nonzero exit is
@@ -128,6 +134,33 @@ export function classifyFailureOutput(output) {
     return lines.some(isInfraLine) ? "infra" : undefined;
 }
 const normalizeLine = (l) => l.replace(/\d+/g, "#").replace(/\s+/g, " ").trim();
+// Vitest's default reporter names file durations as
+// `✓ |project| tests/example.test.ts (12 tests) 1.23s` (❯ for a red file). The runner may be
+// turbo-prefixed, but a test-name timing has no parenthesized file tally and therefore cannot enter
+// this measurement. These are observations of runner output, not a promise that every runner exposes
+// them — callers record null, never zero, when no line matches.
+const FILE_DURATION_RE = /^\s*(?:(?:[\w@./-]+:\s*)*)[✓✔×❯]\s+(?:\|[^|\r\n]+\|\s+)?(\S+)\s+\([^\r\n)]*\)\s+(\d+(?:\.\d+)?)\s*(ms|s|m)\b/;
+const durationUnitMs = (unit) => unit === "m" ? 60_000 : unit === "s" ? 1_000 : 1;
+function fileTiming(output, wallClockMs) {
+    const files = [];
+    for (const line of output.split("\n")) {
+        const match = FILE_DURATION_RE.exec(line.replace(ANSI_RE, ""));
+        if (!match)
+            continue;
+        const durationMs = Number(match[2]) * durationUnitMs(match[3]);
+        if (Number.isFinite(durationMs))
+            files.push({ file: match[1], durationMs });
+    }
+    if (!files.length)
+        return { fileDurationSumMs: null, impliedParallelism: null, longestFile: null };
+    const fileDurationSumMs = files.reduce((sum, entry) => sum + entry.durationMs, 0);
+    const longestFile = files.reduce((longest, entry) => entry.durationMs > longest.durationMs ? entry : longest);
+    return {
+        fileDurationSumMs,
+        impliedParallelism: wallClockMs > 0 ? fileDurationSumMs / wallClockMs : null,
+        longestFile,
+    };
+}
 // A failing command whose output holds no shape any runner here names. The marker is content-free and
 // constant: downstream consumers (tip verify journals fingerprint counts) still see that the command
 // failed, while no line of the output — narration, status strip, stack trace — can enter the set. Being
@@ -363,16 +396,26 @@ export async function captureBaseline(cwd, commands) {
             console.error(`tickmarkr: baseline capture for "${name}" was killed at its ${CAPTURE_CEILING_MS}ms ceiling — `
                 + `it recorded NO fingerprints, so nothing is forgiven and every gate will treat a pre-existing `
                 + `failure as a fresh one. Raise the ceiling or shorten the command.`);
-            base.commands[name] = { infra: true, fingerprints: [], durationMs, ceilingMs: effectiveCeilingMs({ durationMs }) };
+            base.commands[name] = {
+                infra: true,
+                fingerprints: [],
+                durationMs,
+                fileDurationSumMs: null,
+                impliedParallelism: null,
+                longestFile: null,
+                ceilingMs: effectiveCeilingMs({ durationMs }),
+            };
             continue;
         }
+        const raw = (r.stdout + "\n" + r.stderr).split(cwd).join("");
         base.commands[name] = {
             exitCode: r.code,
             // a command that exits 0 has no failures to fingerprint — recording any would be a lie the
             // compare step then has to forgive
-            fingerprints: r.code === 0 ? [] : fingerprint((r.stdout + "\n" + r.stderr).split(cwd).join("")),
+            fingerprints: r.code === 0 ? [] : fingerprint(raw),
             missingCommand: missingConfiguredCommand(cmd, r),
             durationMs,
+            ...fileTiming(raw, durationMs),
             ceilingMs: effectiveCeilingMs({ durationMs }),
         };
     }

package/dist/run/git.d.ts

@@ -1,3 +1,4 @@
+import { spawn } from "node:child_process";
 import { ROUTING_ENV_SEAMS } from "../route/router.js";
 export { ROUTING_ENV_SEAMS };
 export declare const FORK_CAP_ENV = "VITEST_MAX_FORKS";
@@ -42,6 +43,10 @@ export interface ShResult {
     timedOut?: boolean;
     durationMs?: number;
 }
+export declare const setSpawnForTests: (fn: typeof spawn) => void;
+export declare const resetSpawnForTests: () => void;
+export declare const SPAWN_ATTEMPT_LIMIT = 4;
+export declare const SPAWN_RETRY_BACKOFF_MS = 50;
 export declare function sh(cmd: string, cwd: string, timeoutMs?: number): Promise<ShResult>;
 export declare function shGit(cmd: string, cwd: string, timeoutMs?: number): Promise<ShResult>;
 export declare function shOk(cmd: string, cwd: string): Promise<string>;

package/dist/run/git.js

@@ -64,6 +64,31 @@ export const runWithForkBudget = (concurrency, fn) => forkBudget.run(String(deri
 export const resolvedForkCap = () => forkBudget.getStore() ?? DEFAULT_FORK_CAP;
 /** The shipped shell ceiling: the fallback every caller gets when nothing measured a better one. */
 export const DEFAULT_SHELL_TIMEOUT_MS = 600000;
+/**
+ * OBS-688: every gate, every baseline capture and every tip verification reaches the machine through
+ * this one seam, and the seam took its spawn from the standard library directly — so the one failure
+ * it must handle, the kernel REFUSING the fork, was unreachable from a fixture and could only be
+ * described. It is injectable here for exactly that reason; production always holds `spawn` itself.
+ * Undefined-until-set, never captured at module load: the standard library binding stays read at
+ * CALL time, exactly as before this seam existed, so a suite that mocks `node:child_process` without
+ * a `spawn` export still imports this module (tests/adapters/pi-auth.test.ts does).
+ */
+let spawnChild;
+export const setSpawnForTests = (fn) => { spawnChild = fn; };
+export const resetSpawnForTests = () => { spawnChild = undefined; };
+/**
+ * A refusal is NOT evidence about the work: the command never started, so nothing ran, and a retry
+ * cannot repeat a side effect. That argument is the whole safety case for retrying here, and it
+ * holds for exactly one closed case — the kernel refused the fork for a temporary resource shortage
+ * (EAGAIN: the fork table is full, which a gate burst does to a box twice in one night). Every
+ * other spawn error is a standing fact about the machine — a missing interpreter above all — and
+ * retrying it buys nothing while delaying every genuine failure by the whole backoff, so it returns
+ * on the first read. The retry is also gated on the child having produced NO byte and never having
+ * emitted `spawn`: past either, a command has run and re-running it is a side effect, never a retry.
+ */
+const RETRYABLE_SPAWN_CODE = "EAGAIN";
+export const SPAWN_ATTEMPT_LIMIT = 4;
+export const SPAWN_RETRY_BACKOFF_MS = 50;
 // stdin "ignore": same class as HARD-05 / SubprocessDriver — never leave an open pipe a child can block on
 // (pi -p / codex exec wait for stdin EOF). timedOut distinguishes SIGKILL-timeout from a real nonzero exit.
 function shell(cmd, cwd, timeoutMs, login) {
@@ -77,14 +102,14 @@ function shell(cmd, cwd, timeoutMs, login) {
     // OBS-110: apply the run's own fork cap only when the operator has not already set one.
     if (!(FORK_CAP_ENV in env))
         env[FORK_CAP_ENV] = resolvedForkCap();
-    return new Promise((resolve) => {
+    const attempt = () => new Promise((resolve) => {
         const startedAt = Date.now();
         // detached: bash gets its own process group so a timeout can kill the whole tree —
         // SIGKILLing bash alone orphans grandchildren (codex/pi) that hold the stdio pipes
         // open, so "close" never fires and the promise wedges forever (v1.33.1 init hang).
-        const p = spawn("bash", [login ? "-lc" : "-c", cmd], { cwd, env, stdio: ["ignore", "pipe", "pipe"], detached: true });
+        const p = (spawnChild ?? spawn)("bash", [login ? "-lc" : "-c", cmd], { cwd, env, stdio: ["ignore", "pipe", "pipe"], detached: true });
         let stdout = "", stderr = "";
-        let timedOut = false, done = false;
+        let timedOut = false, done = false, started = false;
         const finish = (code, err) => {
             if (done)
                 return;
@@ -101,14 +126,37 @@ function shell(cmd, cwd, timeoutMs, login) {
                 p.kill("SIGKILL");
             }
         }, timeoutMs);
+        p.on("spawn", () => { started = true; }); // the command exists from here on — never retryable past it
         p.stdout.on("data", (d) => (stdout += d));
         p.stderr.on("data", (d) => (stderr += d));
-        p.on("error", (e) => finish(127, String(e)));
+        p.on("error", (e) => {
+            if (!done && !started && !stdout && !stderr && e.code === RETRYABLE_SPAWN_CODE) {
+                done = true;
+                clearTimeout(timer);
+                resolve({ refused: e });
+                return;
+            }
+            finish(127, String(e));
+        });
         p.on("close", (code) => finish(code ?? 1));
         // "close" waits for stdio to drain; a surviving pipe-holder must not outlive the timeout
         p.on("exit", (code) => { if (timedOut)
             finish(code ?? 1); });
     });
+    return (async () => {
+        const startedAt = Date.now();
+        for (let n = 1;; n++) {
+            const r = await attempt();
+            if (!("refused" in r))
+                return r;
+            // Bounded, and the bound is what makes a persisting shortage a REPORTED failure rather than a
+            // wedged daemon: past it the caller gets the refusal's own text under exit 127, as before.
+            if (n >= SPAWN_ATTEMPT_LIMIT) {
+                return { code: 127, stdout: "", stderr: String(r.refused), durationMs: Date.now() - startedAt };
+            }
+            await new Promise((wake) => setTimeout(wake, SPAWN_RETRY_BACKOFF_MS * n));
+        }
+    })();
 }
 export function sh(cmd, cwd, timeoutMs = DEFAULT_SHELL_TIMEOUT_MS) {
     return shell(cmd, cwd, timeoutMs, true);