tickmarkr 2.6.0 → 2.6.1

package/dist/run/git.d.ts

@@ -4,6 +4,18 @@ import { ROUTING_ENV_SEAMS } from "../route/router.js";
 export { ROUTING_ENV_SEAMS };
 export declare const FORK_CAP_ENV = "VITEST_MAX_FORKS";
 export declare const SUITE_PARENT_ENV = "TICKMARKR_SUITE_PARENT";
+/** OBS-1173 add.2: only ps's clean "no such process" (exit 1, nothing printed) means gone (""). A
+ *  timeout, a signal, a spawn error or any other exit is a FAILED probe (null) that says nothing. */
+export declare function classifyIdentityProbe(error: {
+    code?: number | string | null;
+    killed?: boolean;
+    signal?: string | null;
+} | null, stdout: string): string | null;
+/** `undefined` = the pid is gone; `null` = the probe failed and proves nothing (never gone, never a match). */
+export declare function processIdentity(pid: number): Promise<string | null | undefined>;
+export declare const activeShellIdentities: () => ReadonlyMap<number, string | undefined>;
+/** A process that started after its receipt is a pid reuse, never that receipt's child. */
+export declare function resolveActiveShellIdentities(): Promise<void>;
 export declare const DEFAULT_FORK_CAP = "6";
 /** Verification uses command leases; workers keep their concurrency budget. */
 export declare const runWithVerificationBudget: <T>(capacity: RunCapacity, fn: () => Promise<T>) => Promise<T>;
@@ -174,6 +186,23 @@ export declare function cleanupRunWorktrees(repo: string, branch: string, opts:
     removeTaskIds: string[];
 }): Promise<void>;
 export declare function resolveIntegrationBranch(_repo: string, branch: string): Promise<string>;
+/**
+ * The attempt whose worker last wrote in a checkout, or explicit "unknown" when no worker launch is
+ * on record for the current tree (gate-only recreations, standalone verify, legacy callers). The
+ * label is what the preserve commit trailer and every `worktree-preserved`/refusal row carry, so a
+ * preserved engine commit is never credited to whichever seat is dispatched next.
+ */
+export type PreserveProducer = {
+    channel: string;
+    attempt: number;
+} | "unknown";
+export declare const PRESERVE_PRODUCER_TRAILER = "Tickmarkr-Producer";
+/** Subject of every engine preserve commit; only such commits are owned by their preserve row. */
+export declare const PRESERVE_COMMIT_SUBJECT = "tickmarkr: preserve uncommitted worktree";
+export declare const producerFields: (producer: PreserveProducer | undefined) => {
+    producer: string;
+    producerAttempt?: number;
+};
 /**
  * Preserve the bytes an existing checkout holds before recreation removes it.
  *
@@ -188,7 +217,13 @@ export declare function resolveIntegrationBranch(_repo: string, branch: string):
  * neither a commit nor a ref, keeping meaningful deaths visible rather than minting one ref per
  * ordinary dispatch.
  */
-export declare function preserveWorktree(cwd: string): Promise<string | undefined>;
+export declare function preserveWorktree(cwd: string, producer?: PreserveProducer): Promise<string | undefined>;
+/**
+ * Identity of the physical checkout, including recreation at the same path. Unlike mtime/ctime,
+ * birthtime does not change when builds add outputs. Read from disk on every call so process
+ * restarts preserve reuse. Filesystems without birthtime cannot prove build-output continuity.
+ */
+export declare function checkoutIncarnation(worktree: string): string | undefined;
 export declare function createWorktree(repo: string, branch: string, baseRef: string): Promise<string>;
 export interface DependencyLink {
     /** Package link, relative to node_modules (including @scope/name). */

package/dist/run/git.js

@@ -1,7 +1,7 @@
 import { executionSignal } from "./execution-budget.js";
 import { commandLeaseEnvironment, withCommandLease } from "./lease.js";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { execFileSync, spawn } from "node:child_process";
+import { execFile, execFileSync, spawn } from "node:child_process";
 import { existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, readlinkSync, realpathSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
 import { availableParallelism, homedir, tmpdir } from "node:os";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
@@ -16,6 +16,52 @@ export { ROUTING_ENV_SEAMS };
 // as argv (OBS-55) so child test oracles stay intact. The operator's own export wins.
 export const FORK_CAP_ENV = "VITEST_MAX_FORKS";
 export const SUITE_PARENT_ENV = "TICKMARKR_SUITE_PARENT";
+/** A pid is an address, not an identity. Keep this evidence out of ShellReceipt. */
+const linuxIdentity = (pid) => {
+    try {
+        const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+        const start = stat.slice(stat.lastIndexOf(")") + 2).split(/\s+/)[19];
+        return start && /^\d+$/.test(start) ? `${pid}:${start}` : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+/** OBS-1173 add.2: only ps's clean "no such process" (exit 1, nothing printed) means gone (""). A
+ *  timeout, a signal, a spawn error or any other exit is a FAILED probe (null) that says nothing. */
+export function classifyIdentityProbe(error, stdout) {
+    const start = stdout.trim().replace(/\s+/g, " ");
+    if (!error)
+        return start || null;
+    return !error.killed && !error.signal && error.code === 1 && !start ? "" : null;
+}
+/** `undefined` = the pid is gone; `null` = the probe failed and proves nothing (never gone, never a match). */
+export async function processIdentity(pid) {
+    if (process.platform === "linux")
+        return linuxIdentity(pid);
+    // Async and bounded like every other ps probe: a loaded host is slow, not unreadable.
+    const start = await new Promise((done) => execFile("ps", ["-p", String(pid), "-o", "lstart="], {
+        encoding: "utf8", timeout: 15_000, maxBuffer: 4096,
+    }, (error, stdout) => done(classifyIdentityProbe(error, stdout))));
+    if (start === null)
+        return null;
+    return start ? `${pid}:${start}` : undefined;
+}
+// Started receipts own these live pids; terminal receipts retire exactly that invocation. The
+// shell hot path never probes: Linux reads /proc in place, other hosts resolve on demand below.
+const activeShells = new Map();
+export const activeShellIdentities = () => new Map([...activeShells].map(([pid, live]) => [pid, live.identity ?? undefined]));
+/** A process that started after its receipt is a pid reuse, never that receipt's child. */
+export async function resolveActiveShellIdentities() {
+    await Promise.all([...activeShells].filter(([, live]) => live.identity === undefined).map(async ([pid, live]) => {
+        const identity = await processIdentity(pid);
+        if (identity === null)
+            return; // a failed probe resolves nothing; the next resolve retries
+        const started = identity ? Date.parse(identity.slice(identity.indexOf(":") + 1)) : NaN;
+        if (live.identity === undefined)
+            live.identity = identity && started <= live.startedMs + 1_000 ? identity : null;
+    }));
+}
 export const DEFAULT_FORK_CAP = "6";
 /** Worker concurrency is resolved once per run and isolated from other async runs. */
 const forkBudget = new AsyncLocalStorage();
@@ -217,6 +263,8 @@ export function shell(cmd, cwd, timeoutMs, login = false, options = {}) {
     let attribution;
     let confirmedStart = false;
     let terminal = false;
+    let activePid;
+    let activeInvocation;
     const begin = (invocation) => {
         attribution = options.receiptAttribution?.(invocation);
         confirmedStart = false;
@@ -225,10 +273,21 @@ export function shell(cmd, cwd, timeoutMs, login = false, options = {}) {
     const emit = (receipt) => {
         if (terminal)
             return;
-        if (receipt.outcome === "started")
+        if (receipt.outcome === "started") {
             confirmedStart = true;
-        else
+            activePid = receipt.pid;
+            if (activePid !== undefined) {
+                activeInvocation = Symbol("shell invocation");
+                activeShells.set(activePid, { startedMs: Date.now(), invocation: activeInvocation,
+                    ...(process.platform === "linux" ? { identity: linuxIdentity(activePid) ?? null } : {}) });
+            }
+        }
+        else {
             terminal = true;
+            if (activePid !== undefined && activeShells.get(activePid)?.invocation === activeInvocation)
+                activeShells.delete(activePid);
+            activePid = undefined;
+        }
         // Observational callbacks must not change process cleanup, retries or cancellation.
         try {
             options.onReceipt?.({ ...receipt, confirmedStart, ...(attribution ? { attribution: { ...attribution } } : {}) });
@@ -540,6 +599,14 @@ const resolveTaskBranch = async (repo, branch) => {
     const integration = await resolveIntegrationBranch(repo, branch.slice(0, split));
     return `${integration}${branch.slice(split)}`;
 };
+export const PRESERVE_PRODUCER_TRAILER = "Tickmarkr-Producer";
+/** Subject of every engine preserve commit; only such commits are owned by their preserve row. */
+export const PRESERVE_COMMIT_SUBJECT = "tickmarkr: preserve uncommitted worktree";
+export const producerFields = (producer) => producer && producer !== "unknown" ? { producer: producer.channel, producerAttempt: producer.attempt } : { producer: "unknown" };
+const producerLabel = (producer) => {
+    const f = producerFields(producer);
+    return f.producerAttempt === undefined ? f.producer : `${f.producer} attempt ${f.producerAttempt}`;
+};
 /**
  * Preserve the bytes an existing checkout holds before recreation removes it.
  *
@@ -554,7 +621,7 @@ const resolveTaskBranch = async (repo, branch) => {
  * neither a commit nor a ref, keeping meaningful deaths visible rather than minting one ref per
  * ordinary dispatch.
  */
-export async function preserveWorktree(cwd) {
+export async function preserveWorktree(cwd, producer = "unknown") {
     if (!existsSync(cwd))
         return undefined;
     const scratch = mkdtempSync(join(tmpdir(), "tickmarkr-preserve-index-"));
@@ -571,7 +638,7 @@ export async function preserveWorktree(cwd) {
         // not an authored project commit. Its HEAD parent makes the preserved tree directly inspectable.
         const identity = "GIT_AUTHOR_NAME=tickmarkr GIT_AUTHOR_EMAIL=tickmarkr@localhost "
             + "GIT_COMMITTER_NAME=tickmarkr GIT_COMMITTER_EMAIL=tickmarkr@localhost";
-        const commit = (await shGitOk(`${identity} git commit-tree ${shq(tree)} -p HEAD -m ${shq("tickmarkr: preserve uncommitted worktree")}`, cwd)).trim();
+        const commit = (await shGitOk(`${identity} git commit-tree ${shq(tree)} -p HEAD -m ${shq(PRESERVE_COMMIT_SUBJECT)} -m ${shq(`${PRESERVE_PRODUCER_TRAILER}: ${producerLabel(producer)}`)}`, cwd)).trim();
         const ref = `refs/tickmarkr/preserved/${commit}`;
         await shGitOk(`git update-ref ${shq(ref)} ${shq(commit)}`, cwd);
         return ref;
@@ -580,6 +647,23 @@ export async function preserveWorktree(cwd) {
         rmSync(scratch, { recursive: true, force: true });
     }
 }
+/**
+ * Identity of the physical checkout, including recreation at the same path. Unlike mtime/ctime,
+ * birthtime does not change when builds add outputs. Read from disk on every call so process
+ * restarts preserve reuse. Filesystems without birthtime cannot prove build-output continuity.
+ */
+export function checkoutIncarnation(worktree) {
+    try {
+        const root = realpathSync(worktree);
+        const stat = statSync(root, { bigint: true });
+        if (!stat.isDirectory() || stat.birthtimeNs <= 0n)
+            return undefined;
+        return `${root}:${stat.dev}:${stat.ino}:${stat.birthtimeNs}`;
+    }
+    catch {
+        return undefined;
+    }
+}
 export async function createWorktree(repo, branch, baseRef) {
     branch = await resolveTaskBranch(repo, branch);
     const dir = join(tickmarkrDir(repo), WORKTREES_DIR, sanitize(branch));

package/dist/run/host-health.d.ts

@@ -0,0 +1,20 @@
+import { spawn } from "node:child_process";
+export declare const HOST_PROBE_SAMPLES = 3;
+export declare const HOST_PROBE_SAMPLE_MS = 1000;
+export declare const HOST_LATENCY_FLOOR_MS = 50;
+export declare const HOST_LATENCY_RATIO = 3;
+export declare class HostDegradedError extends Error {
+}
+export declare const setHostProbeSpawnForTests: (fn: typeof spawn) => void;
+export declare const resetHostProbeSpawnForTests: () => void;
+declare const execLatency: (signal: AbortSignal, timeoutMs: number) => Promise<number | null>;
+export declare const setHostLatencySampleForTests: (fn: typeof execLatency) => void;
+export declare const resetHostLatencySampleForTests: () => void;
+export interface HostObservation {
+    samplesMs: Array<number | null>;
+    medianMs: number | null;
+}
+/** Three sequential samples, each bounded by 1s and the remaining observation budget. */
+export declare function observeHost(signal: AbortSignal, budgetMs?: number): Promise<HostObservation>;
+export declare const hostDegraded: (observation: HostObservation, referenceMs: number | undefined) => boolean;
+export {};

package/dist/run/host-health.js

@@ -0,0 +1,64 @@
+import { spawn } from "node:child_process";
+import { performance } from "node:perf_hooks";
+import { FILE_HANG_SLACK } from "../gates/test-manifest.js";
+export const HOST_PROBE_SAMPLES = 3;
+export const HOST_PROBE_SAMPLE_MS = 1_000;
+export const HOST_LATENCY_FLOOR_MS = 50;
+export const HOST_LATENCY_RATIO = FILE_HANG_SLACK;
+export class HostDegradedError extends Error {
+}
+// A probe owns just this child: no shell, descendants, inherited Node options, or host-wide kills.
+let probeSpawn = spawn;
+export const setHostProbeSpawnForTests = (fn) => { probeSpawn = fn; };
+export const resetHostProbeSpawnForTests = () => { probeSpawn = spawn; };
+const execLatency = (signal, timeoutMs) => new Promise((resolve, reject) => {
+    signal.throwIfAborted();
+    const start = performance.now();
+    const env = { ...process.env };
+    delete env.NODE_OPTIONS;
+    let child;
+    try {
+        child = probeSpawn(process.execPath, ["-e", ""], { stdio: "ignore", env });
+    }
+    catch {
+        resolve(null);
+        return;
+    }
+    let unreadable = false;
+    const retire = () => { unreadable = true; child.kill("SIGKILL"); };
+    const timer = setTimeout(retire, timeoutMs);
+    signal.addEventListener("abort", retire, { once: true });
+    child.once("error", () => { unreadable = true; });
+    // Resolve only after close: cancellation and timeout must reap the owned child before returning.
+    child.once("close", code => {
+        clearTimeout(timer);
+        signal.removeEventListener("abort", retire);
+        if (signal.aborted)
+            reject(signal.reason);
+        else {
+            const elapsed = performance.now() - start;
+            resolve(!unreadable && code === 0 && elapsed <= timeoutMs ? elapsed : null);
+        }
+    });
+    if (signal.aborted)
+        retire();
+});
+let sample = execLatency;
+export const setHostLatencySampleForTests = (fn) => { sample = fn; };
+export const resetHostLatencySampleForTests = () => { sample = execLatency; };
+/** Three sequential samples, each bounded by 1s and the remaining observation budget. */
+export async function observeHost(signal, budgetMs = HOST_PROBE_SAMPLES * HOST_PROBE_SAMPLE_MS) {
+    const deadline = performance.now() + budgetMs;
+    const samplesMs = [];
+    for (let i = 0; i < HOST_PROBE_SAMPLES; i++) {
+        signal.throwIfAborted();
+        const remaining = deadline - performance.now();
+        const value = remaining > 0 ? await sample(signal, Math.min(HOST_PROBE_SAMPLE_MS, remaining)) : null;
+        samplesMs.push(value !== null && Number.isFinite(value) && value > 0 ? value : null);
+    }
+    const medianMs = samplesMs.every((n) => n !== null)
+        ? [...samplesMs].sort((a, b) => a - b)[1] : null;
+    return { samplesMs, medianMs };
+}
+export const hostDegraded = (observation, referenceMs) => observation.medianMs === null || referenceMs === undefined
+    || observation.medianMs >= Math.max(HOST_LATENCY_FLOOR_MS, referenceMs * HOST_LATENCY_RATIO);

package/dist/run/journal.js

@@ -1673,6 +1673,15 @@ export class Journal {
                     lastDispatch.delete(e.taskId);
                 }
             }
+            else if (e.event === "capacity-requeue") {
+                // OBS-1161: a capacity requeue is free — the daemon re-dispatches the SAME attempt on the SAME
+                // seat — so the dispatch it closes must not count, or a resume bills every busy-seat wait
+                // against MAX_ATTEMPTS. Only the attempt rewinds: the seat stays tried and in force (busy, not
+                // burned). Idempotent by the same rule as the scope rewind: only the OUTSTANDING dispatch.
+                const st = m.get(e.taskId);
+                if (st && lastDispatch.delete(e.taskId))
+                    st.attempts = Math.max(0, st.attempts - 1);
+            }
             else if (e.event === "consult-verdict" && e.data.action === "reroute") {
                 // A reroute bans the in-force channel; retry/decompose/human verdicts ban nothing (D-03).
                 pendingReroute.add(e.taskId);

package/dist/run/operator-state.d.ts

@@ -11,11 +11,18 @@ export interface OperatorRecord extends EvidenceIdentity {
     event: JournalEvent;
 }
 export type OperatorTaskState = "unknown" | "pending" | "running" | "completed" | "merged" | "failed" | "human" | "blocked";
-export type OperatorGateState = "unknown" | "not-run" | "disabled" | "running" | "passed" | "failed";
+export type OperatorGateState = "unknown" | "not-run" | "disabled" | "queued" | "running" | "passed" | "failed";
 export interface OperatorGate {
     state: OperatorGateState;
     evidence?: EvidenceIdentity;
 }
+export interface GateActivity {
+    state: "queued" | "running";
+    gate?: string;
+    reason?: "suite-wait" | "host-degraded";
+    count?: number;
+    evidence: EvidenceIdentity;
+}
 export interface OperatorTask {
     id: string;
     title?: string;
@@ -30,10 +37,14 @@ export interface OperatorTask {
     evidence?: EvidenceIdentity;
     mergeEvidence?: EvidenceIdentity;
     gates: Record<string, OperatorGate>;
+    gateActivity?: GateActivity;
     /** BD-1: the board's per-task counters — latest dispatch channel, review verdicts drawn, human parks. */
     channel?: string;
     reviewRounds: number;
     parks: number;
+    /** Distinct producing channels of the merged subject from task-done; "unknown" names unattributed preserved work.
+     * Kept apart from `channel`: the last-dispatched seat may have authored nothing. */
+    authors?: readonly string[];
 }
 export interface OperatorSnapshot {
     sequence: number;
@@ -47,6 +58,10 @@ export interface OperatorSnapshot {
     label: string;
     green: boolean;
     currentTip: "passed" | "not required" | "pending" | "failed" | "unknown";
+    graphAvailability?: {
+        status: "readable" | "absent" | "unreadable";
+        error?: string;
+    };
     comparable: boolean;
     comparison: "matching graph" | "not comparable";
     merged: number;
@@ -60,6 +75,12 @@ export interface OperatorSnapshot {
     latestRunEnd?: EvidenceIdentity;
     approvedResumeRequired: boolean;
 }
+/** Author channels recorded on a task-done row. A row written before authors were recorded carries none and
+ * projects nothing (never the dispatch); unattributed preserved work arrives as an explicit "unknown" entry. */
+export declare const doneAuthors: (data: Record<string, unknown>) => string[] | undefined;
+/** The note a status row or board row shows beside the last-dispatched channel when the merged
+ * authors are not exactly that channel (a carry-only seat, a mixed subject, or legacy unknown). */
+export declare const authorsNote: (authors: readonly string[] | undefined, channel: string | undefined) => string | undefined;
 /** Incremental pure lifecycle fold. Retains facts per task/gate, never verdict bodies or event history. */
 export declare class OperatorStateFold {
     private tasks;
@@ -78,11 +99,12 @@ export declare class OperatorStateFold {
     private total;
     apply(record: OperatorRecord): void;
     private task;
-    snapshot({ graph, sequence, observedAt, readable }?: {
+    snapshot({ graph, sequence, observedAt, readable, graphAvailability }?: {
         graph?: RunGraph;
         sequence?: number;
         observedAt?: number;
         readable?: boolean;
+        graphAvailability?: OperatorSnapshot["graphAvailability"];
     }): OperatorSnapshot;
     private comparableTo;
 }

package/dist/run/operator-state.js

@@ -5,6 +5,12 @@ const bucketNames = ["failed", "human", "blocked", "pending"];
 const strings = (value) => Array.isArray(value) && value.every(v => typeof v === "string") ? [...value] : undefined;
 const identity = ({ source, line, id, generation }) => ({ source, line, id, generation });
 const emptyGates = () => Object.fromEntries(GATE_NAMES.map(g => [g, { state: "not-run" }]));
+/** Author channels recorded on a task-done row. A row written before authors were recorded carries none and
+ * projects nothing (never the dispatch); unattributed preserved work arrives as an explicit "unknown" entry. */
+export const doneAuthors = (data) => strings(data.authors);
+/** The note a status row or board row shows beside the last-dispatched channel when the merged
+ * authors are not exactly that channel (a carry-only seat, a mixed subject, or legacy unknown). */
+export const authorsNote = (authors, channel) => authors === undefined || (authors.length === 1 && authors[0] === channel) ? undefined : `authors ${authors.join("+")}`;
 /** Incremental pure lifecycle fold. Retains facts per task/gate, never verdict bodies or event history. */
 export class OperatorStateFold {
     tasks = new Map();
@@ -75,6 +81,7 @@ export class OperatorStateFold {
             t.dispatches++;
             t.parkKind = undefined;
             t.gates = emptyGates();
+            t.gateActivity = undefined;
             t.attempt = typeof e.data.attempt === "number" ? e.data.attempt : undefined;
             // These are recorded values only: no guessed directory or universal silence threshold.
             t.path = typeof e.data.worktree === "string" ? e.data.worktree : typeof e.data.cwd === "string" ? e.data.cwd : undefined;
@@ -84,8 +91,10 @@ export class OperatorStateFold {
             if (a && typeof a.adapter === "string" && typeof a.model === "string")
                 t.channel = `${a.adapter}:${a.model}`;
         }
-        if (e.event === "task-done")
+        if (e.event === "task-done") {
             t.state = "completed";
+            t.authors = doneAuthors(e.data);
+        }
         if (e.event === "merge") {
             t.state = "merged";
             t.merged = true;
@@ -104,12 +113,39 @@ export class OperatorStateFold {
         if (e.event === "task-approved") {
             t.state = "pending";
             t.parkKind = undefined;
+            t.gateActivity = undefined;
             this.approved = !this.active;
+            if (e.data.release === "recheck")
+                t.gates = emptyGates();
+        }
+        if (e.event === "phase-start" && e.data.phase === "gates")
+            t.gateActivity = undefined;
+        if (e.event === "suite-wait" || e.event === "host-degraded") {
+            // Only this row's attribution is authority. Legacy task-only waits must not borrow a red gate.
+            const gate = typeof e.data.gate === "string" && GATE_NAMES.includes(e.data.gate) ? e.data.gate : undefined;
+            t.gateActivity = { state: "queued", gate, reason: e.event, evidence: ref,
+                ...(typeof e.data.count === "number" ? { count: e.data.count } : {}) };
+            if (gate)
+                t.gates[gate] = { state: "queued", evidence: ref };
+        }
+        if (e.event === "suite-admitted")
+            t.gateActivity = undefined;
+        if (["task-done", "merge", "task-failed", "task-human", "task-blocked"].includes(e.event))
+            t.gateActivity = undefined;
+        const phaseGate = e.event === "phase-start" && typeof e.data.phase === "string"
+            ? e.data.phase.startsWith("gate:") ? e.data.phase.slice(5) : e.data.phase === "judge" ? "acceptance" : e.data.phase === "review" ? "review" : undefined
+            : undefined;
+        const gate = e.data.gate ?? phaseGate;
+        if ((e.event === "phase-start" && (phaseGate !== undefined || e.data.gate !== undefined)) || e.event === "gate-start" || e.event === "gate-phase-start") {
+            t.gateActivity = { state: "running", evidence: ref };
         }
-        const gate = e.data.gate;
         if (typeof gate === "string" && GATE_NAMES.includes(gate)) {
-            if (e.event === "gate-start")
+            if (e.event === "gate-start" || e.event === "gate-phase-start" || e.event === "phase-start") {
                 t.gates[gate] = { state: "running", evidence: ref };
+                t.gateActivity = { state: "running", gate, evidence: ref };
+            }
+            if (e.event === "gate-result" && t.gateActivity?.gate === gate)
+                t.gateActivity = undefined;
             if (e.event === "gate-result" && gate === "review")
                 t.reviewRounds++;
             if (e.event === "gate-result")
@@ -126,7 +162,7 @@ export class OperatorStateFold {
         }
         return t;
     }
-    snapshot({ graph, sequence = 0, observedAt = Date.now(), readable = true } = {}) {
+    snapshot({ graph, sequence = 0, observedAt = Date.now(), readable = true, graphAvailability } = {}) {
         const hash = graph && graphDefinitionHash(graph);
         const comparable = this.comparableTo(hash);
         const ids = comparable ? [...graph.tasks.map(t => t.id), ...[...this.tasks.keys()].filter(id => !graph.tasks.some(t => t.id === id))] : [...this.tasks.keys()];
@@ -150,7 +186,7 @@ export class OperatorStateFold {
         return {
             sequence, observedAt, lastEventAt: this.lastEventAt, firstEventAt: this.firstEventAt, resumes: this.resumes, escalations: this.escalations, lifecycle,
             label: this.approved ? "approved; resume required" : lifecycle,
-            green, currentTip, comparable, comparison: comparable ? "matching graph" : "not comparable",
+            green, currentTip, graphAvailability, comparable, comparison: comparable ? "matching graph" : "not comparable",
             merged,
             planned, tasks, buckets,
             gatesRan: { passed: this.passed, total: this.total }, latestRunEnd: this.end?.evidence,

package/dist/run/stall.d.ts

@@ -13,7 +13,42 @@ export declare function resetHarvestCpuFlatMsForTests(): void;
 /** The dispatch shell records its foreground group in an attempt-unique artifact. */
 export declare function readOwnedProcessGroup(path: string): number | undefined;
 /** Never infer ownership from a task name or scan another attempt's marker when reaping. */
-export declare function reapOwnedProcessGroup(group: number | undefined, cwd: string): Promise<number[] | null>;
+export declare function reapOwnedProcessGroup(group: number | undefined, cwd: string, ownership?: WorkerReapOwnership): Promise<number[] | null>;
+export interface ReapProcess {
+    pid: number;
+    ppid: number;
+    group: number;
+    session: string;
+    identity: string;
+    command: string;
+    startedAt?: string;
+}
+export interface WorkerReapOwnership {
+    marker: string;
+    /** Session recorded by the dispatch shell before its children can detach. */
+    session?: string;
+    parent?: {
+        pid: number;
+        startedAt: string;
+    };
+    identities?: Map<number, string>;
+    /** Descendants observed while the dispatch root was still alive. */
+    descendants?: Map<number, string>;
+    excludedGroups: number[];
+    excludedWorktrees: string[];
+    /** Discovery evidence is distinct from the final survivor census. */
+    strays: number[];
+}
+/** Bounded host boundary, also used to inject unreadability and pid reuse in regressions. */
+export declare const workerReapHost: {
+    snapshot(): Promise<ReapProcess[] | undefined>;
+    inspect(pid: number): Promise<{
+        cwd: string;
+        suiteParent?: number;
+    } | undefined>;
+    identity: (pid: number) => Promise<string | null | undefined>;
+    kill(pid: number): void;
+};
 export declare function workerTreeCpuMs(marker: string, cwd: string): Promise<{
     ms: number;
     resolutionMs: number;
@@ -22,6 +57,7 @@ export declare class WorkerTreeCpuAccountant {
     private marker;
     private cwd;
     private group?;
+    private identities?;
     private active;
     private loop;
     private live;
@@ -29,7 +65,7 @@ export declare class WorkerTreeCpuAccountant {
     private gaps;
     private consecutiveGaps;
     private latest;
-    constructor(marker: string, cwd: string, group?: (() => number | undefined) | undefined);
+    constructor(marker: string, cwd: string, group?: (() => number | undefined) | undefined, identities?: Map<number, string> | undefined);
     private sample;
     start(): Promise<void>;
     read(): {