tickmarkr 2.6.0 → 2.6.2

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/run/supervision.d.ts

@@ -48,6 +48,7 @@ export interface SupervisionArm {
 export declare const supervisionArmPath: (repoRoot: string, tier: SupervisionTier) => string;
 /** Explicit arming acknowledges the current marker without deleting it. */
 export declare function newSupervisionArm(repoRoot: string, tier: SupervisionTier, armId?: string, initial?: boolean): SupervisionArm;
+export declare const supervisionPresencePath: (repoRoot: string, tier: SupervisionTier, id: string) => string;
 export declare function beatSupervision(repoRoot: string, tier: SupervisionTier, seat?: string, observation?: SupervisionBeatObservation, options?: {
     arm?: SupervisionArm;
     armId?: string;
@@ -69,7 +70,10 @@ export declare function supervisionStatus(repoRoot: string, tier: SupervisionTie
 export declare const readSupervision: (repoRoot: string, now?: number) => TierLiveness[];
 /** One line, one word per tier. Shared by both status surfaces so neither can render a state twice. */
 export declare const supervisionText: (tiers: readonly TierLiveness[], divider?: string) => string;
-/** A board's durable identity is independent of its short title and of other observers. */
+/** A board's durable identity is independent of its short title and of other observers.
+ *  `handle` is the terminal the claiming observer reports running in, when its host exports one: the
+ *  one fact that names the board's pane when the placing split's receipt never arrived (OBS-1172).
+ *  `retired` marks a tombstone a driver keeps in the record's place; it is never answered again. */
 export interface WatchBoardOwner {
     repo: string;
     runId: string;
@@ -80,6 +84,8 @@ export interface WatchBoardOwner {
     token: string;
     pid?: number;
     armId?: string;
+    handle?: string;
+    retired?: true;
 }
 export declare const WATCH_OWNER_ENV = "TICKMARKR_WATCH_OWNER";
 export declare function readWatchBoard(repo: string, runId: string): WatchBoardOwner | undefined;

package/dist/run/supervision.js

@@ -154,7 +154,7 @@ const supervisionObligationPath = (repoRoot, tier) => join(supervisionDir(repoRo
 // Freshness decides presence, never a process table (SUP-02): a watcher that is killed cannot remove
 // its own file, and an unremoved file ages past the same ceiling a beat does and stops counting.
 const presencePrefix = (tier) => `${tier}.live.`;
-const supervisionPresencePath = (repoRoot, tier, id) => join(supervisionDir(repoRoot), `${presencePrefix(tier)}${id}`);
+export const supervisionPresencePath = (repoRoot, tier, id) => join(supervisionDir(repoRoot), `${presencePrefix(tier)}${id}`);
 /** Every presence file on this tier, by name. Missing directory ⇒ nobody is present. */
 const presenceNames = (repoRoot, tier) => {
     try {
@@ -567,6 +567,8 @@ export const supervisionText = (tiers, divider = " · ") => `supervision: ${tier
     `${t.clearOwedSince ? ` CLEAR-OWED since ${t.clearOwedSince}` : ""}` +
     `${t.clearOwedUnreadable ? " CLEAR-OWED unreadable" : ""}`).join(divider)}`;
 export const WATCH_OWNER_ENV = "TICKMARKR_WATCH_OWNER";
+/** Orca exports each terminal's own handle into the processes it runs. */
+const TERMINAL_HANDLE_ENV = "ORCA_TERMINAL_HANDLE";
 const boardPath = (repo, runId) => join(supervisionDir(repo), `watch-board.${parseRunId(runId)}.json`);
 const boardMessagePath = (owner, kind) => {
     if (!/^[a-f0-9-]{36}$/.test(owner.token))
@@ -642,7 +644,8 @@ export function observeNamedRun(repo, runId, env = process.env) {
             const candidate = readWatchBoard(repo, runId);
             if (!candidate || candidate.token !== token || candidate.pid !== undefined)
                 throw new Error("watch ownership unknown; refusing narrator acknowledgement");
-            owner = { ...candidate, pid: process.pid, armId: armed.id };
+            const handle = env[TERMINAL_HANDLE_ENV]?.trim();
+            owner = { ...candidate, pid: process.pid, armId: armed.id, ...(handle ? { handle } : {}) };
             atomicRecord(boardPath(repo, runId), owner);
         }
     }

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).         */
@@ -46,9 +47,9 @@ const AREAS = [
     ["FLEET", [/^src\/(route|config|adapters)\//]],
     ["RUN", [/^src\/(run|drivers|eval)\//]],
     ["GATE", [/^src\/gates\//]],
-    ["UI", [/^src\/(cli|tui|report)\//, /^src\/brand\.ts/]],
-    ["DOCS", [/^(docs|skills)\//]],
-    ["REPO", [/^(scripts|schema)\//, /^\.github\//, /^tests\/(lint|repo|helpers)\//, /^(vitest\.config|package\.json|tsconfig)/]],
+    ["UI", [/^src\/(cli|tui|report)\//, /^src\/brand\.ts/, /^tests\/cockpit\//]],
+    ["DOCS", [/^(docs|skills)\//, /^\.claude\/skills\//]],
+    ["REPO", [/^(scripts|schema)\//, /^\.github\//, /^tests\/(lint|repo|helpers|fixtures)\//, /^(vitest\.config|package\.json|tsconfig)/]],
 ];
 export const BOARD_AREA_ORDER = AREAS.map(([n]) => n);
 const expandBraces = (p) => {
@@ -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/decision-actions.d.ts

@@ -25,6 +25,10 @@ export interface DecisionCommand {
     readonly reason?: string;
     /** `--review-rounds`: the review-round ceiling the release carries. */
     readonly reviewRounds?: number;
+    /** OBS-1178: `--park <line>@<ts>` — the displayed park this decision binds to. */
+    readonly park?: string;
+    /** OBS-1178: `--gate <gate>` — the failed gate a waive binds to. */
+    readonly gate?: string;
 }
 /** The exact argv the production command receives — built only from the closed verb set. */
 export declare function decisionArgv(command: DecisionCommand, { runId, by }: {
@@ -57,13 +61,11 @@ export declare const journalFileFor: (cwd: string, runId: string) => string;
  * the named verb is outside the park's table, so a confirm inset can never promise a decision the
  * command would refuse. The enactor is read from the run lock now, and read again at the receipt.
  */
-export declare function previewDecision(command: DecisionCommand, { cwd, runId, by }: {
+export declare function previewDecision(named: DecisionCommand, { cwd, runId, by }: {
     cwd: string;
     runId: string;
     by: string;
 }): DecisionPreviewResult;
-/** Who enacts it — the three lock states, each stated by the command's own sentence. */
-export declare function enactmentLines(run: ApprovalRunOwner, disposition: ApprovalDisposition): string[];
 /** The confirm inset: run/task, the newest park line, actor/reason, exact argv, consequence, enactor. */
 export declare function decisionConfirmLines(preview: DecisionPreview): readonly string[];
 /** The task-approved row the file gained, located by its physical line. */
@@ -135,8 +137,7 @@ export interface DecisionKeyResult {
 /**
  * The reducer never writes and never reads a file; it names commands. `a` opens the menu for the
  * selected park (a diagnostic park opens a menu with no verbs, stating why); ↑↓ move; Enter picks a
- * verb — which OPENS the confirm inset, never confirms; `y` on a confirm names the write; `n`/Esc
- * cancel the deepest layer. Enter on a confirm is inert by construction.
+ * verb opens the confirm inset; `y` names the write; `n`/Esc cancel the deepest layer. Enter on a confirm is inert.
  */
 export declare function applyDecisionKey(session: DecisionSession, event: DecisionKeyEvent, selected: RunDecision | undefined): DecisionKeyResult;
 /** Store the preview a picked verb produced — or its refusal as the notice. */
@@ -145,3 +146,5 @@ export declare function withDecisionPreview(session: DecisionSession, result: De
 export declare function withDecisionReceipt(session: DecisionSession, receipt: DecisionReceipt): DecisionSession;
 /** The verbs the keybar may advertise for the current layer — nothing the flow cannot honour. */
 export declare function decisionKeybar(session: DecisionSession, selected: RunDecision | undefined): string;
+/** Who enacts it — the three lock states, each stated by the command's own sentence. */
+export declare function enactmentLines(run: ApprovalRunOwner, disposition: ApprovalDisposition): string[];