tickmarkr 2.5.9 → 2.6.1

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(): {

package/dist/run/stall.js

@@ -1,5 +1,7 @@
-import { existsSync, readFileSync } from "node:fs";
-import { shGit } from "./git.js";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { execFile } from "node:child_process";
+import { isAbsolute, relative, sep } from "node:path";
+import { activeShellIdentities, processIdentity, resolveActiveShellIdentities, shGit, SUITE_PARENT_ENV } from "./git.js";
 // OBS-82: normalize known presentation tokens before measuring transcript extent or filtering an
 // LLM-bound transcript. This remains a closed allowlist — ANSI/VT escapes, braille-range spinner
 // glyphs, and elapsed-time tokens bound to time-unit suffixes. Every other byte passes through
@@ -64,7 +66,9 @@ export function readOwnedProcessGroup(path) {
     }
 }
 /** Never infer ownership from a task name or scan another attempt's marker when reaping. */
-export async function reapOwnedProcessGroup(group, cwd) {
+export async function reapOwnedProcessGroup(group, cwd, ownership) {
+    if (ownership)
+        return reapWorkerProcesses(group, cwd, ownership);
     if (group === undefined)
         return null;
     const own = await shGit(`ps -o pgid= -p ${process.pid}`, cwd, 5_000);
@@ -97,6 +101,259 @@ export async function reapOwnedProcessGroup(group, cwd) {
     }
     return survivors;
 }
+const below = (root, path) => {
+    const rel = relative(root, path);
+    return rel === "" || (rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
+};
+// Every probe is async and bounded like the CPU accountant's ps: a loaded host is slow, not unreadable.
+const probeExec = (command, args) => new Promise((resolve, reject) => execFile(command, args, { encoding: "utf8", timeout: 15_000, maxBuffer: 4 * 1024 * 1024 }, (error, stdout) => (error ? reject(error) : resolve(stdout))));
+/** Bounded host boundary, also used to inject unreadability and pid reuse in regressions. */
+export const workerReapHost = {
+    async snapshot() {
+        try {
+            const out = await probeExec("ps", ["-Awwo", "pid=,ppid=,pgid=,sess=,stat=,lstart=,command="]);
+            const rows = [];
+            const lines = out.split("\n").filter((line) => line.trim());
+            if (!lines.length || lines.length > 20_000)
+                return undefined;
+            for (const line of lines) {
+                const m = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(\S+)\s+(\S+\s+\S+\s+\d+\s+\S+\s+\d+)\s+(.*)$/.exec(line);
+                if (!m)
+                    return undefined;
+                if (m[5].startsWith("Z"))
+                    continue;
+                const pid = Number(m[1]);
+                const identity = process.platform === "linux" ? await processIdentity(pid) : `${pid}:${m[6].trim().replace(/\s+/g, " ")}`;
+                // A process disappearing during ps is normal; a present, unreadable identity is not.
+                if (!identity) {
+                    try {
+                        process.kill(pid, 0);
+                        return undefined;
+                    }
+                    catch (error) {
+                        if (error.code !== "ESRCH")
+                            return undefined;
+                    }
+                    continue;
+                }
+                rows.push({ pid, ppid: Number(m[2]), group: Number(m[3]), session: m[4], identity,
+                    startedAt: m[6].trim().replace(/\s+/g, " "), command: m[7] });
+            }
+            return rows;
+        }
+        catch {
+            return undefined;
+        }
+    },
+    async inspect(pid) {
+        try {
+            let cwd;
+            let env;
+            if (process.platform === "linux") {
+                cwd = realpathSync(`/proc/${pid}/cwd`);
+                env = readFileSync(`/proc/${pid}/environ`, "utf8").split("\0");
+            }
+            else {
+                const [open, command] = await Promise.all([
+                    probeExec("lsof", ["-a", "-p", String(pid), "-d", "cwd", "-Fn"]),
+                    probeExec("ps", ["eww", "-p", String(pid), "-o", "command="]),
+                ]);
+                const path = open.split("\n").find((line) => line.startsWith("n"))?.slice(1);
+                if (!path)
+                    return undefined;
+                cwd = realpathSync(path);
+                env = command.split(/\s+/);
+            }
+            const parent = env.find((entry) => entry.startsWith(`${SUITE_PARENT_ENV}=`))?.slice(SUITE_PARENT_ENV.length + 1);
+            return { cwd, ...(parent && /^\d+$/.test(parent) ? { suiteParent: Number(parent) } : {}) };
+        }
+        catch {
+            return undefined;
+        }
+    },
+    // Lazy: a partial module mock of git.js must not fail at import time.
+    identity: (pid) => processIdentity(pid),
+    kill(pid) { process.kill(pid, "SIGKILL"); },
+};
+async function reapWorkerProcesses(group, cwd, ownership) {
+    let root;
+    let excludedPaths;
+    try {
+        root = realpathSync(cwd);
+        excludedPaths = ownership.excludedWorktrees.map((path) => realpathSync(path));
+    }
+    catch {
+        return null;
+    }
+    let rows = await workerReapHost.snapshot();
+    if (!rows)
+        return null;
+    const roots = rows.filter((row) => row.command === `bash ${ownership.marker}` || row.command === `/bin/bash ${ownership.marker}`);
+    // Ownership evidence: the recorded group, a live dispatch root, or descendants observed while it
+    // lived. cwd alone is never authority, and neither is the session id (OBS-1170): on Linux a
+    // same-session SIBLING that never descended from the dispatch — an operator job in a kept pane
+    // whose cwd is the worktree — is not ours to signal. `ownership.session` stays recorded as
+    // evidence only. With none of these in a readable snapshot nothing owned is observable: the
+    // dispatch has retired, so the census is empty rather than unknown (a finished root leaves no row).
+    const groupRows = group === undefined ? [] : rows.filter((row) => row.group === group && row.pid !== process.pid);
+    if (roots.length === 0 && !ownership.descendants?.size && groupRows.length === 0)
+        return [];
+    const owned = new Map(ownership.descendants);
+    const protectedIds = new Map();
+    const recordedParent = rows.find((row) => row.pid === ownership.parent?.pid && row.startedAt === ownership.parent.startedAt);
+    // Never reap a pane's shell (an ancestor of the dispatch root), or the daemon.
+    for (const start of [...roots.map((row) => row.ppid), ...(recordedParent ? [recordedParent.pid] : []), process.pid]) {
+        const seen = new Set();
+        for (let pid = start; pid && !seen.has(pid);) {
+            seen.add(pid);
+            const row = rows.find((p) => p.pid === pid);
+            if (!row)
+                break;
+            protectedIds.set(pid, row.identity);
+            pid = row.ppid;
+        }
+    }
+    const targets = new Map();
+    const observed = ownership.identities ?? new Map();
+    for (const [pid, identity] of owned)
+        if (!observed.has(pid))
+            observed.set(pid, identity);
+    for (const row of rows)
+        if (!observed.has(row.pid))
+            observed.set(row.pid, row.identity);
+    let unknown = false;
+    // Bounds the whole sweep; each probe is bounded on its own (15 s) and never blocks the loop.
+    const deadline = Date.now() + 60_000;
+    // One cwd verdict per identity: a later round never re-probes a process it already classified.
+    const inspected = new Set();
+    const discover = async (snapshot) => {
+        const children = new Map();
+        for (const row of snapshot) {
+            const siblings = children.get(row.ppid) ?? [];
+            siblings.push(row.pid);
+            children.set(row.ppid, siblings);
+        }
+        const descendants = (seeds, stop = new Set()) => {
+            const queue = [...seeds];
+            for (let index = 0; index < queue.length; index++) {
+                for (const pid of children.get(queue[index]) ?? [])
+                    if (!seeds.has(pid) && !stop.has(pid)) {
+                        seeds.add(pid);
+                        queue.push(pid);
+                    }
+            }
+        };
+        const tree = new Set(snapshot.filter((row) => owned.get(row.pid) === row.identity || roots.some((r) => r.pid === row.pid && r.identity === row.identity)
+            || (group !== undefined && row.group === group)).map((row) => row.pid));
+        descendants(tree);
+        await resolveActiveShellIdentities();
+        const receipts = activeShellIdentities();
+        for (const [pid, identity] of receipts)
+            if (identity === undefined && tree.has(pid))
+                unknown = true;
+        const excluded = new Set(snapshot.filter((row) => row.pid === process.pid
+            || ownership.excludedGroups.includes(row.group)
+            || (receipts.has(row.pid) && (receipts.get(row.pid) === undefined || receipts.get(row.pid) === row.identity))).map((row) => row.pid));
+        // A daemon ancestor is protected, but the explicitly owned dispatch branch is not.
+        descendants(excluded, new Set(snapshot.filter((row) => roots.some((r) => r.pid === row.pid && r.identity === row.identity)).map((row) => row.pid)));
+        for (const row of snapshot)
+            if (protectedIds.get(row.pid) === row.identity)
+                excluded.add(row.pid);
+        const candidates = [];
+        for (const row of snapshot) {
+            if (!tree.has(row.pid) || excluded.has(row.pid))
+                continue;
+            if (observed.has(row.pid) && observed.get(row.pid) !== row.identity) {
+                unknown = true;
+                continue;
+            }
+            observed.set(row.pid, row.identity);
+            owned.set(row.pid, row.identity);
+            if (!inspected.has(row.identity)) {
+                inspected.add(row.identity);
+                candidates.push(row);
+            }
+        }
+        if (candidates.length && Date.now() > deadline) {
+            unknown = true;
+            return;
+        }
+        // Probe concurrently, then record verdicts in snapshot order.
+        const verdicts = await Promise.all(candidates.map(async (row) => {
+            const details = await workerReapHost.inspect(row.pid);
+            // A child that exited between the snapshot and this probe is a normal race, not
+            // unreadable ownership; only a still-live identity with no readable cwd is unknown.
+            // OBS-1173 add.2: a FAILED recheck (null) is unknown too — it never reads as gone.
+            if (!details) {
+                const recheck = await workerReapHost.identity(row.pid);
+                return recheck === row.identity || recheck === null ? "unknown" : "spared";
+            }
+            if (details.suiteParent === process.pid || excludedPaths.some((path) => below(path, details.cwd)))
+                return "spared";
+            if (!below(root, details.cwd))
+                return "spared";
+            // OBS-1173: the same race after a readable cwd — a short-lived tool child that exits between
+            // inspect and this recheck is gone, not unreadable. Only a live, different identity — or a
+            // failed probe (null, OBS-1173 add.2), which is never gone — is unknown.
+            const current = await workerReapHost.identity(row.pid);
+            if (current === row.identity)
+                return "target";
+            return current === undefined ? "spared" : "unknown";
+        }));
+        candidates.forEach((row, index) => {
+            if (verdicts[index] === "unknown")
+                unknown = true;
+            if (verdicts[index] !== "target")
+                return;
+            targets.set(row.pid, row.identity);
+            if (row.group !== group && !ownership.strays.includes(row.pid))
+                ownership.strays.push(row.pid);
+        });
+    };
+    await discover(rows); // capture detached ancestry before killing its parents
+    // A protected/foreign group member rules out a group signal. Signal only proven identities.
+    const members = group === undefined ? [] : rows.filter((row) => row.group === group);
+    if (group !== undefined && members.length && members.every((row) => targets.get(row.pid) === row.identity)
+        && (await Promise.all(members.map((row) => workerReapHost.identity(row.pid)))).every((identity, index) => identity === members[index].identity)) {
+        try {
+            workerReapHost.kill(-group);
+        }
+        catch (error) {
+            if (error.code !== "ESRCH")
+                unknown = true;
+        }
+    }
+    let survivors = [];
+    if (targets.size === 0)
+        return unknown ? null : [];
+    for (let probe = 0; probe < 5; probe++) {
+        // Revalidate immediately before each signal, including after any slow cwd probe.
+        await Promise.all([...targets].map(async ([pid, identity]) => {
+            const current = await workerReapHost.identity(pid);
+            if (current !== identity) {
+                if (current !== undefined)
+                    unknown = true;
+                return;
+            }
+            try {
+                workerReapHost.kill(pid);
+            }
+            catch (error) {
+                if (error.code !== "ESRCH")
+                    unknown = true;
+            }
+        }));
+        await new Promise((resolve) => setTimeout(resolve, probe === 0 ? 10 : 50));
+        rows = await workerReapHost.snapshot();
+        if (!rows || Date.now() > deadline)
+            return null;
+        await discover(rows);
+        survivors = rows.filter((row) => targets.get(row.pid) === row.identity).map((row) => row.pid);
+        if (!survivors.length)
+            return unknown ? null : [];
+    }
+    return unknown ? null : survivors;
+}
 let linuxClockTickMs;
 function linuxProcessCpuMs(pid, cwd) {
     if (!existsSync("/proc/self/stat"))
@@ -126,7 +383,7 @@ function linuxProcessCpuMs(pid, cwd) {
 // Every non-seeded worker process descends from its attempt-unique dispatch script. One ps snapshot
 // finds that root and its descendants. An empty tree is measurable zero; a failed or unparseable
 // snapshot is undefined because missing evidence can never prove inactivity.
-async function workerTreeCpuSnapshot(marker, cwd, group) {
+async function workerTreeCpuSnapshot(marker, cwd, group, identities) {
     const snapshot = await shGit("ps -Awwo pid=,ppid=,time=,command=", cwd, 15_000);
     if (snapshot.code !== 0)
         return undefined;
@@ -142,6 +399,8 @@ async function workerTreeCpuSnapshot(marker, cwd, group) {
     if (rows.length === 0)
         return undefined;
     const tree = new Set(rows.filter((p) => p.cmd.includes(marker)).map((p) => p.pid));
+    // CPU presentation matching is intentionally broader than authority to signal a process.
+    const owned = new Set(rows.filter((p) => p.cmd === `bash ${marker}` || p.cmd === `/bin/bash ${marker}`).map((p) => p.pid));
     if (group !== undefined) {
         const groups = await shGit("ps -Awwo pid=,pgid=", cwd, 15_000);
         if (groups.code !== 0)
@@ -156,6 +415,10 @@ async function workerTreeCpuSnapshot(marker, cwd, group) {
     for (let grew = true; grew;) {
         grew = false;
         for (const p of rows) {
+            if (!owned.has(p.pid) && owned.has(p.ppid)) {
+                owned.add(p.pid);
+                grew = true;
+            }
             if (!tree.has(p.pid) && tree.has(p.ppid)) {
                 tree.add(p.pid);
                 grew = true;
@@ -167,6 +430,11 @@ async function workerTreeCpuSnapshot(marker, cwd, group) {
     for (const p of rows) {
         if (!tree.has(p.pid))
             continue;
+        if (identities && owned.has(p.pid) && !identities.has(Number(p.pid))) {
+            const identity = await processIdentity(Number(p.pid));
+            if (identity)
+                identities.set(Number(p.pid), identity);
+        }
         const cpu = await linuxProcessCpuMs(p.pid, cwd);
         precise.set(p.pid, cpu?.ms ?? p.cpuMs);
         if (cpu !== undefined)
@@ -197,6 +465,7 @@ export class WorkerTreeCpuAccountant {
     marker;
     cwd;
     group;
+    identities;
     active = false;
     loop;
     live = new Map();
@@ -204,13 +473,14 @@ export class WorkerTreeCpuAccountant {
     gaps = 0;
     consecutiveGaps = 0;
     latest;
-    constructor(marker, cwd, group) {
+    constructor(marker, cwd, group, identities) {
         this.marker = marker;
         this.cwd = cwd;
         this.group = group;
+        this.identities = identities;
     }
     async sample() {
-        const snapshot = await workerTreeCpuSnapshot(this.marker, this.cwd, this.group?.());
+        const snapshot = await workerTreeCpuSnapshot(this.marker, this.cwd, this.group?.(), this.identities);
         if (snapshot === undefined) {
             this.gaps++;
             this.live.clear();

package/dist/tui/cockpit/board.d.ts

@@ -1,5 +1,5 @@
 import { type RunGraph } from "../../graph/schema.js";
-import type { OperatorSnapshot } from "../../run/operator-state.js";
+import { type OperatorSnapshot } from "../../run/operator-state.js";
 import type { AttemptHarvest, TaskRow } from "./derive.js";
 /** The prototype's palette (tasks-redesign.mjs:24-30): xterm-256 indices, stated once. */
 export declare const BOARD_PALETTE: {

package/dist/tui/cockpit/board.js

@@ -1,4 +1,5 @@
 import { GATE_NAMES } from "../../graph/schema.js";
+import { authorsNote } from "../../run/operator-state.js";
 import { cellWidth, sliceCells } from "./width.js";
 /* ------------------------------------------------------------------------ */
 /* BD-1 — the approved task board (RULING-231-19 §2, OBS-965 add.2).         */
@@ -113,14 +114,15 @@ export function boardFrame(input, width) {
     // recompile) lends nothing — no titles, deps, declarations or denominator — so the rows are the
     // journal's tasks alone and every gate reads as declared.
     const graphTasks = input.graph?.tasks && s.comparable ? input.graph.tasks : s.tasks.map((t) => ({ id: t.id, title: t.title ?? "", deps: [], files: [], gates: undefined }));
-    const uncomparable = input.graph !== undefined && !s.comparable;
+    const uncomparable = !s.comparable;
+    const graphStatus = s.graphAvailability?.status ?? (input.graph ? "readable" : "absent");
     const doneIds = new Set(s.tasks.filter(isDone).map((t) => t.id));
     const t0 = s.firstEventAt ? Date.parse(s.firstEventAt) : input.now;
     const t1 = s.lastEventAt ? Date.parse(s.lastEventAt) : input.now;
     const wide = W >= 118;
     const top = [];
     top.push(`${bg(16, 2)(" tickmarkr ")} ${bold(input.runId)}  ${chrome("│")}  ` +
-        `${pass(`${doneIds.size}/${graphTasks.length} done`)}  ` +
+        `${pass(`${doneIds.size}/${s.comparable ? graphTasks.length : "?"} done`)}  ` +
         (wide
             ? `${chrome("│")}  ${warn(`${s.resumes} restarts`)}  ${chrome("│")}  ${fail(`${s.escalations} escalations`)}  `
             : `${chrome("│")}  ${fail(`${s.escalations} esc`)}  `) +
@@ -145,7 +147,7 @@ export function boardFrame(input, width) {
         top.push(`  ${accent("▌")} ${bold("NOW")}        ${now}`);
         top.push("");
     }
-    top.push(`  ${accent("▌")} ${bold("TASKS")}   ${mute(uncomparable ? `${doneIds.size} of ${graphTasks.length} journal tasks merged · graph not comparable` : `${doneIds.size} of ${graphTasks.length} merged in this graph`)}` +
+    top.push(`  ${accent("▌")} ${bold("TASKS")}   ${mute(uncomparable ? `${doneIds.size} journal tasks merged · ${graphStatus === "readable" ? "graph not comparable" : `graph ${graphStatus}${s.graphAvailability?.error ? `: ${s.graphAvailability.error}` : ""}`}` : `${doneIds.size} of ${graphTasks.length} merged in this graph`)}` +
         (wide ? mute(" · rows in dispatch order · gates left→right in declaration order") : ""));
     top.push("");
     // ── aligned gate header: each label truncated to the cell it owns (prototype :382-394) ──
@@ -170,7 +172,7 @@ export function boardFrame(input, width) {
         };
         const strip = BOARD_GATES.map((k) => {
             const v = cell(k);
-            return pad(v === true ? pass("✔") : v === false ? fail("✖") : !declared.has(k) ? faint("─") : faint("·"), BOARD_CELL);
+            return pad(v === true ? pass("✔") : v === false ? fail("✖") : t?.gates[k]?.state === "queued" ? warn("Q") : t?.gates[k]?.state === "running" ? accent("R") : t?.gates[k]?.state === "unknown" ? warn("?") : t?.gates[k]?.state === "disabled" ? faint("D") : !declared.has(k) ? faint("─") : faint("·"), BOARD_CELL);
         }).join("");
         const unrun = BOARD_GATES.filter((k) => declared.has(k) && cell(k) === undefined).length;
         const failedGates = BOARD_GATES.filter((k) => cell(k) === false);
@@ -204,21 +206,25 @@ export function boardFrame(input, width) {
             parks >= 3 ? park(`◍ parked ×${parks}`) : "",
             reviews > 2 ? warn(`↻ ${reviews} review rounds`) : "",
             failedGates.length ? fail(`✖ ${failedGates.join(",")}`) : "",
-            !attempts
-                ? (() => {
-                    const blockers = depIds.filter((d) => !doneIds.has(d));
-                    if (!blockers.length)
-                        return faint("queued");
-                    const room = Math.max(10, W - BOARD_FIXED - LBL - CHAN);
-                    let shown = blockers, dropped = 0;
-                    while (shown.length > 1 && `waiting on ${shown.join(", ")}`.length + (dropped ? 5 : 0) > room) {
-                        shown = shown.slice(0, -1);
-                        dropped = blockers.length - shown.length;
-                    }
-                    return faint(`waiting on ${shown.join(", ")}${dropped ? ` +${dropped}` : ""}`);
-                })()
-                : unrun === declared.size ? faint("in flight")
-                    : unrun > 2 ? faint(`${declared.size - unrun}/${declared.size} gates run`) : "",
+            // Merged authors beside the last-dispatched channel; equal-to-channel says nothing new.
+            authorsNote(t?.authors, t?.channel) ? faint(authorsNote(t?.authors, t?.channel)) : "",
+            t?.gateActivity
+                ? `${t.gateActivity.state} · ${t.gateActivity.gate ?? "gate unknown"}${t.gateActivity.reason ? ` · ${t.gateActivity.reason}` : ""}${t.gateActivity.count === undefined ? "" : ` (${t.gateActivity.count} suites)`}`
+                : !attempts
+                    ? (() => {
+                        const blockers = depIds.filter((d) => !doneIds.has(d));
+                        if (!blockers.length)
+                            return faint("queued");
+                        const room = Math.max(10, W - BOARD_FIXED - LBL - CHAN);
+                        let shown = blockers, dropped = 0;
+                        while (shown.length > 1 && `waiting on ${shown.join(", ")}`.length + (dropped ? 5 : 0) > room) {
+                            shown = shown.slice(0, -1);
+                            dropped = blockers.length - shown.length;
+                        }
+                        return faint(`waiting on ${shown.join(", ")}${dropped ? ` +${dropped}` : ""}`);
+                    })()
+                    : unrun === declared.size ? faint("in flight")
+                        : unrun > 2 ? faint(`${declared.size - unrun}/${declared.size} gates run`) : "",
         ].filter(Boolean);
         rows.push({
             id: g.id,
@@ -237,6 +243,8 @@ export function boardFrame(input, width) {
         bottom.push(`    ${pad("", 8)}${fail("UNMAPPED")} ${mute([...unmappedPaths].slice(0, 3).join("  "))}${unmappedPaths.size > 3 ? mute(`  +${unmappedPaths.size - 3}`) : ""}`);
     bottom.push(`    ${faint("gates")}   ${BOARD_GATES.map((k) => `${body(k.slice(0, BOARD_CELL - 1))} ${mute(k)}`).join("  ")}`);
     bottom.push(`    ${faint("     ")}   ${pass("✔")} ${mute("passed")}   ${fail("✖")} ${mute("failed")}   ${faint("·")} ${mute("pending")}   ${faint("─")} ${mute("not declared (acceptance and review are the optional two)")}`);
+    if (s.tasks.some(t => Object.values(t.gates).some(cell => ["queued", "running", "unknown", "disabled"].includes(cell.state))))
+        bottom.push(`    ${accent("R")} running   ${warn("Q")} queued   ${warn("?")} unknown   ${faint("D")} disabled`);
     bottom.push("");
     // the gap is stated, never silently skipped — derived, so it cannot go stale
     const retired = s.tasks.map((t) => t.id).filter((id) => !graphTasks.some((g) => g.id === id)).sort();

package/dist/tui/cockpit/derive.d.ts

@@ -115,6 +115,8 @@ export type TaskRow = {
     readonly state?: TaskState;
     readonly attempts?: number;
     readonly actor?: string;
+    /** Distinct merged-author channels from task-done; legacy rows say ["unknown"]. Not the actor. */
+    readonly authors?: readonly string[];
     readonly lastEventTime?: string;
     /** Complete UTC instant paired with `lastEventTime`; additive for existing consumers. */
     readonly lastEventTimestamp?: string;

package/dist/tui/cockpit/derive.js

@@ -1,5 +1,6 @@
 // Consolidated C1/C6 readers use the incremental lifecycle contract; legacy captures keep their API.
 export { readOperatorState as deriveOperatorState } from "../../run/operator-state.js";
+import { doneAuthors } from "../../run/operator-state.js";
 import { channelKey } from "../../adapters/types.js";
 import { newestPark, permittedDecisionVerbs } from "../../cli/commands/approve.js";
 import { parseOwnedName } from "../../drivers/types.js";
@@ -276,6 +277,8 @@ function deriveTasks(events, interrupted) {
         if (state) {
             const fact = task(event.taskId, index, event.ts);
             fact.state = state;
+            if (event.event === "task-done")
+                fact.authors = doneAuthors(event.data);
             // The park kind travels with the park: `task-human` records it, and the
             // next recorded state — approved, done, failed — retires it with the park
             // it named. A resolved state must not leave its badge behind (OBS-256).
@@ -641,6 +644,7 @@ function taskRows(events, tasks, graph, runId) {
             ...(state === undefined ? {} : { state }),
             ...(attempts === 0 ? {} : { attempts }),
             ...(assignment === undefined ? {} : { actor: channelKey(assignment) }),
+            ...(fact?.authors === undefined ? {} : { authors: fact.authors }),
             ...(lastTs === undefined ? {} : { lastEventTime: eventTime(lastTs) }),
             ...(lastTs === undefined ? {} : { lastEventTimestamp: lastTs }),
             ...(title === undefined ? {} : { title }),

package/dist/tui/cockpit/live-runtime.d.ts

@@ -22,6 +22,10 @@ export interface ShellDelivery {
     diagnostics: LiveStore["diagnostics"];
     stage: (edits: readonly string[]) => void;
     geometry: () => ShellCommit | undefined;
+    /** Application render commits since mount (OBS-1132: an idle board adds none). */
+    frames: () => number;
+    /** Model derivations (the App body) since mount. */
+    derivations: () => number;
 }
 export interface ConsolidatedOptions {
     input: NodeJS.ReadStream;