tickmarkr 2.6.0 → 2.6.2

package/dist/tui/cockpit/decision-actions.js

@@ -1,7 +1,7 @@
 import { join } from "node:path";
-import { APPROVAL_ENACTS, approvalDispositionForRelease, approvalEnactment, approvalRunOwner, approve, DECISION_VERBS, newestPark, permittedDecisionVerbs, readJournalEvents, releaseForDecision, } from "../../cli/commands/approve.js";
+import { APPROVAL_ENACTS, approvalDispositionForRelease, approvalEnactment, approvalRunOwner, approve, DECISION_VERBS, newestPark, parkToken, permittedDecisionVerbs, readJournalEvents, releaseForDecision, } from "../../cli/commands/approve.js";
 import { stateDirName } from "../../graph/graph.js";
-import { Journal } from "../../run/journal.js";
+import { bindingToken, effectiveDecisions, Journal, physicalLine, recordedBinding } from "../../run/journal.js";
 const parkDiagnostic = (park) => {
     if (park.kind === "scope-request")
         return park.approveCommand ?? "scope-request requires tickmarkr approve with --files <glob,…>";
@@ -50,6 +50,8 @@ export function decisionArgv(command, { runId, by }) {
     const flag = { approve: [], waive: ["--waive"], uphold: ["--uphold"], recheck: ["--recheck"] }[command.verb];
     return [
         runId, command.taskId, ...flag,
+        ...(command.park === undefined ? [] : ["--park", command.park]),
+        ...(command.gate === undefined ? [] : ["--gate", command.gate]),
         ...(command.reviewRounds === undefined ? [] : ["--review-rounds", String(command.reviewRounds)]),
         "--by", by,
         ...(command.reason === undefined ? [] : ["--reason", command.reason]),
@@ -62,10 +64,9 @@ export const journalFileFor = (cwd, runId) => join(stateDirName(cwd), "runs", ru
  * 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 function previewDecision(command, { cwd, runId, by }) {
-    let argv;
+export function previewDecision(named, { cwd, runId, by }) {
     try {
-        argv = decisionArgv(command, { runId, by });
+        decisionArgv(named, { runId, by });
     }
     catch (e) {
         return { ok: false, refusal: e.message };
@@ -78,15 +79,29 @@ export function previewDecision(command, { cwd, runId, by }) {
     catch (e) {
         return { ok: false, refusal: e.message };
     }
-    const park = newestPark(events, command.taskId, sourceIndexes);
+    const park = newestPark(events, named.taskId, sourceIndexes);
     if (!park)
-        return { ok: false, refusal: `task ${command.taskId} has no park in run ${runId} — nothing to decide` };
+        return { ok: false, refusal: `task ${named.taskId} has no park in run ${runId} — nothing to decide` };
+    // OBS-1178: the argv binds the park this preview displays; approve refuses it once another opens.
+    const token = parkToken(park);
+    if (named.park !== undefined && named.park !== token)
+        return { ok: false, refusal: `task ${named.taskId}'s open park is ${token ?? "untimestamped"}, not ${named.park} — refresh and decide the open park` };
+    if (named.gate !== undefined && named.gate !== park.failedGate)
+        return { ok: false, refusal: `refusing mismatched gate for ${named.taskId}: --gate ${named.gate} but park ${token} failed ${park.failedGate ?? "no gate"} — nothing appended` };
+    const command = { ...named, ...(token === undefined ? {} : { park: token }), ...(named.verb === "waive" && named.gate === undefined && park.failedGate !== undefined ? { gate: park.failedGate } : {}) };
+    let argv;
+    try {
+        argv = decisionArgv(command, { runId, by });
+    }
+    catch (e) {
+        return { ok: false, refusal: e.message };
+    }
     const verbs = permittedDecisionVerbs(park);
     if (!verbs.includes(command.verb)) {
         const why = parkDiagnostic(park) ?? `permitted: ${verbs.join(", ")}`;
         return { ok: false, refusal: `${command.verb} is not a decision for ${command.taskId}'s ${park.kind ?? "unknown"} park (${why})` };
     }
-    const released = events.slice(park.index + 1).find((e) => e.event === "task-approved" && e.taskId === command.taskId);
+    const released = releaseSince(events, park.index, command.taskId);
     if (released) {
         return { ok: false, refusal: `task ${command.taskId} was already released at #L${sourceIndexes[events.indexOf(released)] + 1} by ${String(released.data.by ?? "unknown")} — nothing to confirm` };
     }
@@ -100,28 +115,12 @@ export function previewDecision(command, { cwd, runId, by }) {
     };
 }
 const parkLine = (park) => `#L${park.line} ${park.kind ?? "unknown kind"}${park.failedGate ? ` · failed gate ${park.failedGate}` : ""}${park.reason ? ` · ${park.reason}` : ""}`;
-const quoteArg = (arg) => (/^[\w.:/@=-]+$/u.test(arg) ? arg : JSON.stringify(arg));
-/** What a confirmed write buys, from the command's own table — never a phrase of this file's own. */
-function consequenceLines(verb, park, release, disposition) {
-    const lines = [`consequence  disposition ${disposition}; appends one task-approved${release ? ` with release ${release}` : " with no release"}`];
-    if (verb === "waive")
-        lines.push(`             marks gate ${park.failedGate} satisfied; it does NOT mark the task done`);
-    if (verb === "recheck")
-        lines.push("             marks no gate satisfied; the whole declared battery re-runs");
-    if (verb === "uphold")
-        lines.push("             sides with the reviewer; funds one fixed attempt carrying the findings");
-    lines.push(`             it will ${APPROVAL_ENACTS[disposition]}`);
-    return lines;
-}
-/** Who enacts it — the three lock states, each stated by the command's own sentence. */
-export function enactmentLines(run, disposition) {
-    const owner = run.live
-        ? "enactment    matching live daemon — pending daemon enactment at its next task boundary"
-        : run.blockingRunId
-            ? `enactment    other live run \`${run.blockingRunId}\` holds the repository lock — recorded, not dispatched`
-            : `enactment    no live owner — recorded, not dispatched; resume required: tickmarkr resume ${run.runId}`;
-    return [owner, `             ${approvalEnactment(disposition, run)}`];
+/** The decision already open on this park, if any. OBS-1178: a refused or unsound row released nothing. */
+function releaseSince(events, parkIndex, taskId) {
+    const effective = effectiveDecisions(events);
+    return events.find((e, i) => i > parkIndex && e.event === "task-approved" && e.taskId === taskId && effective.has(physicalLine(events, i)));
 }
+const quoteArg = (arg) => (/^[\w.:/@=-]+$/u.test(arg) ? arg : JSON.stringify(arg));
 /** The confirm inset: run/task, the newest park line, actor/reason, exact argv, consequence, enactor. */
 export function decisionConfirmLines(preview) {
     return [
@@ -157,7 +156,7 @@ export async function executeDecision(preview, { cwd, command = approve }) {
     if (!park || park.index !== preview.park.index || park.line !== preview.park.line || park.kind !== preview.park.kind) {
         return { ok: false, preview, stale: true, refusal: `task ${named.taskId}'s park changed since preview (${park ? `now #L${park.line} ${park.kind ?? "unknown"}` : "no park now"}) — refresh and preview again` };
     }
-    const released = before.slice(park.index + 1).find((e) => e.event === "task-approved" && e.taskId === named.taskId);
+    const released = releaseSince(before, park.index, named.taskId);
     if (released) {
         return { ok: false, preview, stale: true, refusal: `task ${named.taskId} was released at #L${beforeSourceIndexes[before.indexOf(released)] + 1} by ${String(released.data.by ?? "unknown")} after this preview — no second decision appended; refresh` };
     }
@@ -208,6 +207,7 @@ export async function executeDecision(preview, { cwd, command = approve }) {
         via: "cli",
         gate: named.verb === "waive" ? park.failedGate : named.verb === "uphold" ? "review" : undefined,
         reviewRoundCeiling: named.reviewRounds,
+        park: parkToken(park),
     };
     const actual = {
         release,
@@ -216,6 +216,7 @@ export async function executeDecision(preview, { cwd, command = approve }) {
         via: appended.event.data.via,
         gate: appended.event.data.gate,
         reviewRoundCeiling: appended.event.data.reviewRoundCeiling,
+        park: recordedBinding(appended.event.data.park) === undefined ? undefined : bindingToken(recordedBinding(appended.event.data.park)),
     };
     const mismatch = Object.keys(expected)
         .find((field) => actual[field] !== expected[field]);
@@ -264,8 +265,7 @@ export const initialDecisionSession = () => ({ menu: null, confirming: null, rec
 /**
  * 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 function applyDecisionKey(session, event, selected) {
     if (session.confirming !== null) {
@@ -315,3 +315,26 @@ export function decisionKeybar(session, selected) {
         return session.menu.verbs.length === 0 ? "Esc Close" : "↑↓ Choose · Enter Preview · Esc Close";
     return selected === undefined ? "" : "a Actions";
 }
+// Consequence and enactor lines, shared by the confirm inset and the receipt above. Kept below the key
+// grammar so the operator walkthrough's line citations stay put.
+/** What a confirmed write buys, from the command's own table — never a phrase of this file's own. */
+function consequenceLines(verb, park, release, disposition) {
+    const lines = [`consequence  disposition ${disposition}; appends one task-approved${release ? ` with release ${release}` : " with no release"}`];
+    if (verb === "waive")
+        lines.push(`             marks gate ${park.failedGate} satisfied; it does NOT mark the task done`);
+    if (verb === "recheck")
+        lines.push("             marks no gate satisfied; the whole declared battery re-runs");
+    if (verb === "uphold")
+        lines.push("             sides with the reviewer; funds one fixed attempt carrying the findings");
+    lines.push(`             it will ${APPROVAL_ENACTS[disposition]}`);
+    return lines;
+}
+/** Who enacts it — the three lock states, each stated by the command's own sentence. */
+export function enactmentLines(run, disposition) {
+    const owner = run.live
+        ? "enactment    matching live daemon — pending daemon enactment at its next task boundary"
+        : run.blockingRunId
+            ? `enactment    other live run \`${run.blockingRunId}\` holds the repository lock — recorded, not dispatched`
+            : `enactment    no live owner — recorded, not dispatched; resume required: tickmarkr resume ${run.runId}`;
+    return [owner, `             ${approvalEnactment(disposition, run)}`];
+}

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,9 +1,11 @@
 // 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";
 import { projectActivity } from "../../run/activity.js";
+import { effectiveDecisions, withPhysicalLine } from "../../run/journal.js";
 import { isPidLive } from "../../run/lock.js";
 import { normalizeGateOutcome } from "../../run/outcome.js";
 import { projectOperatorSummary } from "../../run/operator-summary.js";
@@ -78,6 +80,15 @@ function parseSource(raw) {
     }
     return { events, defects };
 }
+/**
+ * OBS-1178: the rows the task-state folds read. A refused or unsound decision released nothing, so its
+ * task-approved row is dropped here; the one decision fold keys every row by its physical line. The
+ * journal rows the cockpit draws keep every line as evidence.
+ */
+function decidedEvents(events) {
+    const effective = effectiveDecisions(events.map((event) => withPhysicalLine(event, event.line)));
+    return events.filter((event) => event.event !== "task-approved" || effective.has(event.line));
+}
 function assignmentFrom(value) {
     const assignment = recordValue(value);
     return assignment
@@ -276,6 +287,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 +654,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 }),
@@ -840,7 +854,8 @@ export function deriveRunCockpitData(source, binaryVersion, options = {}) {
         // alive in the lock — the cockpit called a live run interrupted.
         : pid !== undefined && (options.isDaemonAlive ?? isPidLive)(pid);
     const interrupted = !alive;
-    const tasks = deriveTasks(events, interrupted);
+    const decided = decidedEvents(events);
+    const tasks = deriveTasks(decided, interrupted);
     const taskFacts = [...tasks.values()];
     const done = taskFacts.filter((task) => task.state === "done").length;
     const failed = taskFacts.filter((task) => task.state === "failed").length;
@@ -869,7 +884,7 @@ export function deriveRunCockpitData(source, binaryVersion, options = {}) {
     // run-end — the run's own closing statement is enough.
     const runStatus = failed > 0
         ? "failed"
-        : human > 0 || unresolvedSummaryParks(events).length > 0
+        : human > 0 || unresolvedSummaryParks(decided).length > 0
             ? "parked"
             : lifecycle === "superseded" || hasInterruptedTask
                 ? "interrupted"

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

@@ -46,5 +46,15 @@ export interface ConsolidatedOptions {
     environment?: NodeJS.ProcessEnv;
     diagnostics?: readonly HomeNeedsYouTarget[];
 }
+/**
+ * OBS-1178: the store's incremental fold reads every task-approved row as a release. A refused or unsound
+ * decision released nothing, so whenever the rows the store has read hold one — whatever state the raw
+ * fold shows now, since a later run-end restores a park but not the gate evidence a rejected recheck
+ * cleared — the operator snapshot is refolded over the decided rows, each keeping its physical line and
+ * the store's evidence identity.
+ * ponytail: a whole-journal read per observed journal change (parsed only when it holds an approval);
+ * move the decision fold into OperatorStateFold if that ever measures slow.
+ */
+export declare function decidedLiveStore(store: LiveStore): LiveStore;
 /** The live entry mounts the dependency-owned leaves, using only C2 snapshots/history/page. */
 export declare function runConsolidatedCockpit(options: ConsolidatedOptions): Promise<void>;

package/dist/tui/cockpit/live-runtime.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { existsSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { renderMarkdownRecord } from "../../cli/commands/report.js";
 import { loadConfig } from "../../config/config.js";
@@ -20,9 +20,10 @@ import { createPointerReportReader, POINTER_TRACKING_ON, POINTER_TRACKING_OFF }
 import { deriveRunDecisions, previewDecision, executeDecision, withDecisionPreview, withDecisionReceipt, decisionConfirmLines } from "./decision-actions.js";
 import { approvalRunOwner } from "../../cli/commands/approve.js";
 import { GLYPHS } from "../../brand.js";
-import { Journal } from "../../run/journal.js";
+import { effectiveEvents, Journal, parseJournalText, physicalLine } from "../../run/journal.js";
 import { observeNamedRun, WATCH_OWNER_ENV } from "../../run/supervision.js";
 import { formatOwnedName } from "../../drivers/types.js";
+import { readOperatorState } from "../../run/operator-state.js";
 import { cellWidth, wrapCells } from "./width.js";
 import { resolveShellColourMode } from "./theme.js";
 let timelineUsers = 0;
@@ -58,6 +59,52 @@ export function borrowRuntimeTimeline() {
 }
 export const SHELL_TERMINAL_ENTER = "\x1b[?1049h\x1b[22;0t\x1b]0;tickmarkr cockpit\x07" + POINTER_TRACKING_ON;
 export const SHELL_TERMINAL_RESTORE = POINTER_TRACKING_OFF + "\x1b[23;0t\x1b[?25h\x1b[?1049l";
+/**
+ * OBS-1178: the store's incremental fold reads every task-approved row as a release. A refused or unsound
+ * decision released nothing, so whenever the rows the store has read hold one — whatever state the raw
+ * fold shows now, since a later run-end restores a park but not the gate evidence a rejected recheck
+ * cleared — the operator snapshot is refolded over the decided rows, each keeping its physical line and
+ * the store's evidence identity.
+ * ponytail: a whole-journal read per observed journal change (parsed only when it holds an approval);
+ * move the decision fold into OperatorStateFold if that ever measures slow.
+ */
+export function decidedLiveStore(store) {
+    let key;
+    let operator;
+    const decided = (snap) => {
+        const { journal, graph } = snap;
+        const observed = `${journal.source}:${journal.generation}:${journal.offset}:${graph.identity}:${graph.status}`;
+        if (observed !== key) {
+            key = observed;
+            operator = undefined;
+            let bytes;
+            try {
+                bytes = readFileSync(journal.source).subarray(0, journal.offset);
+            }
+            catch {
+                return snap;
+            }
+            if (bytes.includes("task-approved")) {
+                const rows = parseJournalText(bytes.subarray(0, bytes.lastIndexOf(10) + 1).toString("utf8"))
+                    .filter(e => e !== null && typeof e === "object" && typeof e.event === "string" && typeof e.data === "object" && e.data !== null);
+                const kept = effectiveEvents(rows);
+                if (kept.length !== rows.length) {
+                    const events = kept.map((event, i) => {
+                        const line = physicalLine(kept, i);
+                        return { source: journal.source, line, id: `${journal.source}#L${line}`, generation: journal.generation, event };
+                    });
+                    operator = readOperatorState({ events, graph: graph.status === "readable" ? graph.value : undefined,
+                        readable: journal.status === "readable" && journal.backlogBytes === 0 });
+                }
+            }
+        }
+        if (!operator)
+            return snap;
+        const { sequence, observedAt, graphAvailability } = snap.operator;
+        return { ...snap, operator: { ...operator, sequence, observedAt, graphAvailability } };
+    };
+    return { ...store, snapshot: () => decided(store.snapshot()), refresh: () => decided(store.refresh()) };
+}
 /** Preserve a policy-disabled gate from C2 even when C5's generic event
  * mapper calls an unpassed result unknown. Lead with the gate name so a long
  * task identity cannot clip the label that explains the disabled glyph. */
@@ -97,7 +144,7 @@ export async function runConsolidatedCockpit(options) {
             output.write(SHELL_TERMINAL_ENTER);
         }
         store = createLiveStore({ cwd, runId, now: options.now });
-        const source = store;
+        const source = decidedLiveStore(store);
         if (options.observeRun !== false)
             observation = observeNamedRun(cwd, runId, options.environment);
         // BD-1 (RULING-231-19 §2): the daemon-placed board carries the watch owner token and mounts

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

@@ -2,6 +2,7 @@ import { type JournalEvent } from "../../run/journal.js";
 import { type OperatorRecord } from "../../run/operator-state.js";
 export declare const OBSERVATION_INTERVAL_MS = 1000;
 export declare const STORE_LIMITS: {
+    readonly graphBytes: number;
     readonly history: 256;
     readonly historyBytes: number;
     readonly recordBytes: number;

package/dist/tui/cockpit/live-store.js

@@ -1,4 +1,4 @@
-import { closeSync, fstatSync, openSync, readFileSync, readSync, statSync } from "node:fs";
+import { closeSync, fstatSync, openSync, readSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { graphPath, stateDirName } from "../../graph/graph.js";
 import { validateGraph } from "../../graph/schema.js";
@@ -7,7 +7,8 @@ import { isPidLive, STALE_MS } from "../../run/lock.js";
 import { readTierLiveness, SUPERVISION_TIERS } from "../../run/supervision.js";
 import { OperatorStateFold } from "../../run/operator-state.js";
 export const OBSERVATION_INTERVAL_MS = 1_000;
-export const STORE_LIMITS = { history: 256, historyBytes: 2 * 1024 * 1024, recordBytes: 1024 * 1024, readBytes: 1024 * 1024, subscribers: 64, metrics: 12, errors: 32 };
+// Graph declarations have a separate 16 MiB bound; journal retention remains unchanged.
+export const STORE_LIMITS = { graphBytes: 16 * 1024 * 1024, history: 256, historyBytes: 2 * 1024 * 1024, recordBytes: 1024 * 1024, readBytes: 1024 * 1024, subscribers: 64, metrics: 12, errors: 32 };
 const errorText = (e) => e instanceof Error ? e.message : String(e);
 const fileIdentity = (st) => `${st.dev}:${st.ino}`;
 const stamp = (st) => `${fileIdentity(st)}:${st.size}:${st.mtimeNs}:${st.ctimeNs}`;
@@ -192,10 +193,12 @@ export class JournalTail {
 class JsonSource {
     path;
     parse;
+    maxBytes;
     cached;
-    constructor(path, parse) {
+    constructor(path, parse, maxBytes = STORE_LIMITS.recordBytes) {
         this.path = path;
         this.parse = parse;
+        this.maxBytes = maxBytes;
     }
     read(now) {
         try {
@@ -203,9 +206,29 @@ class JsonSource {
             const id = stamp(st);
             if (this.cached?.identity === id && this.cached.status === "readable")
                 return this.cached = { ...this.cached, observedAt: now };
-            if (!st.isFile() || st.size > BigInt(STORE_LIMITS.recordBytes))
-                throw new Error("source is not a bounded regular file");
-            const value = this.parse(readFileSync(this.path, "utf8"));
+            if (!st.isFile())
+                throw new Error("source is not a regular file");
+            if (st.size > BigInt(this.maxBytes))
+                throw new Error(`source exceeds ${this.maxBytes} byte cap`);
+            // Bound the read itself too: a writer can grow the file after stat.
+            const fd = openSync(this.path, "r");
+            let value;
+            try {
+                const bytes = Buffer.alloc(Number(st.size) + 1);
+                let length = 0;
+                while (length < bytes.length) {
+                    const n = readSync(fd, bytes, length, bytes.length - length, length);
+                    if (!n)
+                        break;
+                    length += n;
+                }
+                if (length !== Number(st.size) || stamp(fstatSync(fd, { bigint: true })) !== id)
+                    throw new Error("source changed during read; retry observation");
+                value = this.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, length)));
+            }
+            finally {
+                closeSync(fd);
+            }
             return this.cached = { source: this.path, identity: id, value, status: "readable", observedAt: now };
         }
         catch (e) {
@@ -222,7 +245,7 @@ export function createLiveStore(options) {
     const tail = new JournalTail(join(state, "runs", parseRunId(options.runId), "journal.jsonl"), {
         reset: () => { fold = new OperatorStateFold(); }, record: record => fold.apply(record),
     });
-    const graph = new JsonSource(graphPath(options.cwd), raw => validateGraph(JSON.parse(raw)));
+    const graph = new JsonSource(graphPath(options.cwd), raw => validateGraph(JSON.parse(raw)), STORE_LIMITS.graphBytes);
     const config = new JsonSource(options.configPath ?? join(state, "config.yaml"), raw => raw);
     const cache = new JsonSource(options.cachePath ?? join(state, "doctor.json"), JSON.parse);
     const lock = new JsonSource(join(state, "graph.lock"), raw => {
@@ -256,7 +279,7 @@ export function createLiveStore(options) {
         const readable = journal.status === "readable" && journal.backlogBytes === 0;
         return {
             sequence: ++sequence, observedAt, delayed, freshness: errors.length ? "failed" : delayed ? "delayed" : "fresh",
-            operator: fold.snapshot({ graph: graphReading.status === "readable" ? graphReading.value : undefined, sequence, observedAt, readable }),
+            operator: fold.snapshot({ graph: graphReading.status === "readable" ? graphReading.value : undefined, sequence, observedAt, readable, graphAvailability: { status: graphReading.status, error: graphReading.error } }),
             journal, graph: graphReading, config: configReading, cache: cacheReading,
             lock: { ...owner, state: lockState, alive, expired: owner.identity ? observedAt - Number(owner.identity.split(":")[3]) / 1e6 > STALE_MS : undefined },
             supervision, errors, actionsEnabled: readable && !errors.length && !delayed,

package/dist/tui/cockpit/run-cockpit.d.ts

@@ -34,6 +34,9 @@ export declare function deriveRunViewRows(data: RunCockpitData, viewId: RunViewI
  * task row — identity, phase, build evidence, blocker, next action — each unrecorded field saying so,
  * each recorded one citing the journal line it was read from, and the OBS-1048 stall marker when the
  * newest attempt's harvest is suspect. No attempt label is printed here: the ruler is the row's own.
+ * A task with no recorded dispatch folds identity, phase, and build into one missing-evidence clause
+ * (OBS-1104). A recorded blocker or next action — a pre-dispatch park, a dependency wait — stays,
+ * cited to the journal row that produced it.
  */
 export declare function taskProjectionText(row: TaskRow, journal?: readonly JournalRow[]): string;
 /**

package/dist/tui/cockpit/run-cockpit.js

@@ -3,8 +3,9 @@ import { Box, useApp, useStdout } from "ink";
 import { cloneElement, createContext, useContext, useEffect, useInsertionEffect, useMemo, useRef, useSyncExternalStore, } from "react";
 import { GLYPHS, PLAIN_COMPACT_LOCKUP, } from "../../brand.js";
 import { allocateBandColumns, BandLines, BodyText, CockpitGrid, composeBandLine, JournalRowPanel, keyRosterLines, Panel, PANEL_CHROME_ROWS, ProgressMeter, Sparkline, StatTile, StatusStrip, } from "./components.js";
+import { authorsNote } from "../../run/operator-state.js";
 import { fieldReading } from "./derive.js";
-import { STALL_MARKER } from "./run-view.js";
+import { MISSING_EVIDENCE, STALL_MARKER } from "./run-view.js";
 import { initialRunInteractionState, projectRunKeyEntries, reconcileRunInteraction, RUN_SIDE_RAIL_COLUMN_FLOOR, runPanelFocusOrder, runSideRailVisible, selectableRunViewRowIds, } from "./keys.js";
 import { DECISIONS_TAB_TITLE, RUN_VIEWS, runViewById, setupSectionAt, SETUP_SECTIONS, } from "./views.js";
 import { FRAME_HEADER_GAP, FRAME_NESTED_ROW_BANDS, FULL_JOURNAL_ROWS, planFrame, RUN_PANEL_HORIZONTAL_CHROME, SIDEBAR_COLUMN_FLOOR, } from "./layout.js";
@@ -280,7 +281,7 @@ function promotedViewRows(data, viewId) {
             time: fieldReading(row.lastEventTime),
             ...(row.lastEventTimestamp === undefined ? {} : { timestamp: row.lastEventTimestamp }),
             state: taskRowState(row),
-            text: `${row.taskId} · ${fieldReading(row.state)} · ${runAttemptLabel(row.attempts)} · ${fieldReading(row.actor)}${row.title === undefined ? "" : ` · ${row.title}`} · ${taskProjectionText(row, data.journalRows)}`,
+            text: `${row.taskId} · ${fieldReading(row.state)} · ${runAttemptLabel(row.attempts)} · ${fieldReading(row.actor)}${authorsNote(row.authors, row.actor) === undefined ? "" : ` · ${authorsNote(row.authors, row.actor)}`}${row.title === undefined ? "" : ` · ${row.title}`} · ${taskProjectionText(row, data.journalRows)}`,
         }));
     }
     if (viewId === "gates") {
@@ -308,8 +309,13 @@ function promotedViewRows(data, viewId) {
  * task row — identity, phase, build evidence, blocker, next action — each unrecorded field saying so,
  * each recorded one citing the journal line it was read from, and the OBS-1048 stall marker when the
  * newest attempt's harvest is suspect. No attempt label is printed here: the ruler is the row's own.
+ * A task with no recorded dispatch folds identity, phase, and build into one missing-evidence clause
+ * (OBS-1104). A recorded blocker or next action — a pre-dispatch park, a dependency wait — stays,
+ * cited to the journal row that produced it.
  */
 export function taskProjectionText(row, journal = []) {
+    if ((row.attempts ?? 0) === 0)
+        return undispatchedProjectionText(row, journal);
     const identity = row.identities?.at(-1);
     const blocker = row.summary?.blocker;
     const harvest = row.harvests?.at(-1);
@@ -330,6 +336,26 @@ export function taskProjectionText(row, journal = []) {
         ...(harvest?.suspectedStalledHarvest ? [`${STALL_MARKER} · launch ${at(evidence.launch)} · ${harvest.nudgeFailures} nudge failed ${at(evidence.nudge)} · ${harvest.pageCount} paged ${at(evidence.page)} · no worker-result`] : []),
     ].reduce((text, part) => `${text} · ${part}`);
 }
+/**
+ * Identity, phase, and build are unrecorded until a dispatch. Append the blocker and next action
+ * only when the summary recorded one — an unknown placeholder with no journal row is the missing clause.
+ */
+function undispatchedProjectionText(row, journal) {
+    const blocker = row.summary?.blocker;
+    if (blocker == null)
+        return MISSING_EVIDENCE;
+    const evidence = projectionEvidence(row, journal);
+    const at = (line) => line === undefined ? "(no journal row)" : `#L${line}`;
+    const showBlocker = blocker.kind !== "unknown" || evidence.blocker !== undefined;
+    const showNext = blocker.nextAction != null;
+    if (!showBlocker && !showNext)
+        return MISSING_EVIDENCE;
+    return [
+        MISSING_EVIDENCE,
+        ...(showBlocker ? [`blocker ${blocker.kind} ${at(evidence.blocker)}`] : []),
+        ...(showNext ? [`next ${blocker.nextAction} ${at(evidence.nextAction)}`] : []),
+    ].reduce((text, part) => `${text} · ${part}`);
+}
 /**
  * Correlate each already-derived field with the row that can have produced that value. This is
  * intentionally not a "newest row with a plausible name" lookup: launch identity is paired by

package/dist/tui/cockpit/run-view.d.ts

@@ -1,7 +1,7 @@
 import { type ReactElement } from "react";
 import type { ApprovalRunOwner } from "../../cli/commands/approve.js";
 import { type GateName, type RunGraph } from "../../graph/schema.js";
-import type { JournalEvent } from "../../run/journal.js";
+import { type JournalEvent } from "../../run/journal.js";
 import { type GateOutcome } from "../../run/outcome.js";
 import type { OperatorGateState, OperatorSnapshot, OperatorTask } from "../../run/operator-state.js";
 import { type DecisionCommand, type DecisionPreview, type DecisionSession, type RunDecision } from "./decision-actions.js";
@@ -35,10 +35,8 @@ export interface RunGateCell {
     /** The verdict text the evidence row carries, split into lines for paging. */
     readonly verdict: readonly string[];
 }
-/**
- * The current attempt's seven cells in declaration order. `rows` supplies the later journal rows
- * that give a cell its inherited/satisfied label; only rows for this task after the evidence line count.
- */
+/** Current-attempt cells in declaration order; later task rows supply inherited/satisfied labels.
+ * Only rows after each cell's own evidence line count. */
 export declare function runGateCells(task: OperatorTask, evidence: EvidenceLookup, rows?: readonly RunEvidenceRow[]): readonly RunGateCell[];
 export declare const VERDICT_WINDOW = 10;
 export interface RunViewSession {
@@ -95,8 +93,9 @@ export interface TaskProjection {
     readonly build: ProjectionField;
     readonly blocker: ProjectionField;
     readonly nextAction: ProjectionField;
-    /** OBS-1048: present only when the newest launched attempt has failed nudges, pages and no worker-result. */
+    /** OBS-1048: present only when the newest launched attempt has failed nudges, pages and no worker-result. OBS-1104: neverDispatched collapses that task's line. */
     readonly stalled?: ProjectionField;
+    readonly neverDispatched?: true;
 }
 export declare const STALL_MARKER = "\u26A0 stalled harvest suspected";
 /**
@@ -105,7 +104,12 @@ export declare const STALL_MARKER = "\u26A0 stalled harvest suspected";
  * Nothing is inferred from a title, a provider or a task id: an unrecorded field says so.
  */
 export declare function projectRunTasks(snapshot: OperatorSnapshot, rows: readonly RunEvidenceRow[], graph: RunGraph | undefined, decisions: readonly RunDecision[], runId: string): readonly TaskProjection[];
-/** One wrapped line per task: every field with its line, and the stall marker when the harvest is suspect. */
+/**
+ * OBS-1104: a never-dispatched task has no identity, phase, or build row. Those fold into one
+ * missing-evidence clause. A substantive or journal-cited blocker and next action stay — a
+ * pre-dispatch park and a dependency wait are recorded facts, and dropping them hides the park token.
+ */
+export declare const MISSING_EVIDENCE = "missing evidence";
 export declare const projectionLine: (p: TaskProjection) => string;
 export interface PaneLocator {
     readonly status: "recorded" | "unavailable";