tickmarkr 2.6.1 → 2.6.3

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

@@ -5,7 +5,7 @@ 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";
@@ -309,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);
@@ -329,7 +334,27 @@ export function taskProjectionText(row, journal = []) {
         `blocker ${blocker ? `${blocker.kind} ${at(evidence.blocker)}` : "none"}`,
         `next ${blocker?.nextAction == null ? fieldReading(undefined) : `${blocker.nextAction} ${at(evidence.nextAction)}`}`,
         ...(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}`);
+    ].join(" · ");
+}
+/**
+ * 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)}`] : []),
+    ].join(" · ");
 }
 /**
  * Correlate each already-derived field with the row that can have produced that value. This is

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";
@@ -95,6 +95,8 @@ export interface TaskProjection {
     readonly nextAction: ProjectionField;
     /** OBS-1048: present only when the newest launched attempt has failed nudges, pages and no worker-result. */
     readonly stalled?: ProjectionField;
+    /** OBS-1104: a task with no recorded dispatch collapses its line to one missing-evidence clause. */
+    readonly neverDispatched?: true;
 }
 export declare const STALL_MARKER = "\u26A0 stalled harvest suspected";
 /**
@@ -103,7 +105,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";

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

@@ -5,6 +5,7 @@ import { GLYPHS } from "../../brand.js";
 import { formatOwnedName, parseOwnedName } from "../../drivers/types.js";
 import { GATE_NAMES } from "../../graph/schema.js";
 import { projectActivity } from "../../run/activity.js";
+import { effectiveDecisions, withPhysicalLine } from "../../run/journal.js";
 import { projectOperatorSummary } from "../../run/operator-summary.js";
 import { trackJournalRows } from "../../run/protocol.js";
 import { normalizeGateOutcome } from "../../run/outcome.js";
@@ -122,7 +123,7 @@ export function runGateCells(task, evidence, rows = []) {
             const e = later.event;
             if (e.event === "gate-reused" && e.data.gate === gate)
                 labels.push(`inherited from ${str(e.data.commit) ?? "unknown commit"} · #L${later.line}`);
-            if (e.event === "task-approved" && e.data.release === "gate-satisfied" && e.data.gate === gate)
+            if (e.event === "task-approved" && e.data.release === "gate-satisfied" && e.data.gate === gate && !undecidedLines(evidence.later(0)).has(later.line))
                 labels.push(`satisfied by approval #L${later.line}`);
         }
         const verdict = row?.event?.event === "gate-result" && typeof data?.details === "string" ? data.details.split("\n") : [];
@@ -191,7 +192,7 @@ const readLabel = (f) => `${f.label} ${f.line === undefined ? `(${NO_ROW})` : `#
  * Nothing is inferred from a title, a provider or a task id: an unrecorded field says so.
  */
 export function projectRunTasks(snapshot, rows, graph, decisions, runId) {
-    const ordered = [...rows].filter((r) => r.event !== undefined).sort((a, b) => a.line - b.line);
+    const ordered = decidedRows(rows);
     const graphTask = (id) => graph?.tasks.find((t) => t.id === id);
     const activityTasks = snapshot.tasks.map((t) => ({ id: t.id, gates: graphTask(t.id)?.gates ?? [...GATE_NAMES], deps: graphTask(t.id)?.deps ?? [], status: t.state }));
     const tracked = trackJournalRows(runId, ordered.map((r) => ({ raw: r.event, sourceIndex: r.line })));
@@ -208,7 +209,16 @@ export function projectRunTasks(snapshot, rows, graph, decisions, runId) {
             ...(own.length === 0 ? {} : { phase: activity.get(t.id)?.state, lastEvidenceAt: own.at(-1).event.ts }),
             ...(responsibility ? { responsible: { role: str(responsibility.event.data.role), agent: str(responsibility.event.data.agent) } } : {}),
         };
-    }), decisions.map((d) => ({ taskId: d.taskId, park: { kind: d.park.kind, tombstone: d.park.tombstone, ...(d.park.reason === undefined ? {} : { reason: d.park.reason }) }, verbs: d.verbs, ...(d.diagnostic === undefined ? {} : { diagnostic: d.diagnostic }) }))).map((s) => [s.taskId, s]));
+    }), decisions.map((d) => ({
+        taskId: d.taskId,
+        park: {
+            kind: d.park.kind, tombstone: d.park.tombstone, line: d.park.line,
+            ...(d.park.ts === undefined ? {} : { ts: d.park.ts }),
+            ...(d.park.reason === undefined ? {} : { reason: d.park.reason }),
+        },
+        verbs: d.verbs,
+        ...(d.diagnostic === undefined ? {} : { diagnostic: d.diagnostic }),
+    }))).map((s) => [s.taskId, s]));
     return snapshot.tasks.map((t) => {
         const own = byTask(t.id);
         const act = activity.get(t.id);
@@ -241,8 +251,11 @@ export function projectRunTasks(snapshot, rows, graph, decisions, runId) {
         const blocker = { label: `blocker ${blk ? `${blk.kind}${blk.diagnostic ? ` · ${blk.diagnostic}` : ""}` : "none"}`, ...(blk && blockerRow ? { line: blockerRow.line } : {}) };
         const nextAction = { label: `next ${blk?.nextAction ?? "none"}`, ...(blk?.nextAction && blockerRow ? { line: blockerRow.line } : {}) };
         // OBS-1048 harvest, chronological: the newest worker-launch opens the attempt; a later worker-result retires it.
-        let launched, launchedAttempt, returned = false;
-        const nudges = [], pages = [];
+        let launched;
+        let launchedAttempt;
+        let returned = false;
+        const nudges = [];
+        const pages = [];
         // Finding 1: only rows of the launched attempt count; a row without an attempt belongs to it (derive.ts attemptHarvests).
         const ofLaunched = (d) => launched !== undefined && (ordinal(d.attempt) ?? launchedAttempt) === launchedAttempt;
         for (const r of own) {
@@ -272,7 +285,7 @@ export function projectRunTasks(snapshot, rows, graph, decisions, runId) {
         const stalled = launched !== undefined && !returned && nudges.length > 0 && pages.length > 0
             ? { label: `${STALL_MARKER} · launch #L${launched} · nudge failed ${nudges.map((l) => `#L${l}`).join(",")} · paged ${pages.map((l) => `#L${l}`).join(",")} · no worker-result`, line: launched }
             : undefined;
-        return { taskId: t.id, identity, phase, build, blocker, nextAction, ...(stalled ? { stalled } : {}) };
+        return { taskId: t.id, identity, phase, build, blocker, nextAction, ...(stalled ? { stalled } : {}), ...(t.dispatches === 0 ? { neverDispatched: true } : {}) };
     });
 }
 /** The line at which each projected value last changed, folding the task's rows (and run-level resets) prefix by prefix. */
@@ -299,8 +312,16 @@ function acceptedChanges(runId, tracked, taskId, task) {
     }
     return out;
 }
-/** One wrapped line per task: every field with its line, and the stall marker when the harvest is suspect. */
-export const projectionLine = (p) => [p.taskId, readLabel(p.identity), readLabel(p.phase), readLabel(p.build), readLabel(p.blocker), readLabel(p.nextAction), ...(p.stalled ? [p.stalled.label] : [])].join(" · ");
+/**
+ * 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 const MISSING_EVIDENCE = "missing evidence";
+const UNRECORDED_BLOCKER = new Set(["blocker none", "blocker unknown"]);
+const UNRECORDED_NEXT = new Set(["next none"]);
+const keptWhenUndispatched = (field, unrecorded) => field.line !== undefined || !unrecorded.has(field.label);
+export const projectionLine = (p) => p.neverDispatched === true ? undispatchedProjectionLine(p) : recordedProjectionLine(p);
 /**
  * Where the current attempt's pane is recorded — and only that. The reading is exact-name: the
  * launch row's slot name must be the owned name of THIS task, attempt and run. No terminal is ever
@@ -358,6 +379,30 @@ export function paneLocator(task, rows, runId) {
 }
 /** The board's footer keys merged with the cockpit's own — every one of them handled by this view or the shell. */
 export const RUN_VIEW_KEYS = [...BOARD_KEYS.slice(0, 2), "←→ verdict gate", "PgUp/PgDn page", "x outcome", "a actions", "o pane", "Tab focus", "? keys", BOARD_KEYS[2]];
+function recordedProjectionLine(p) {
+    return [p.taskId, readLabel(p.identity), readLabel(p.phase), readLabel(p.build), readLabel(p.blocker), readLabel(p.nextAction), ...(p.stalled ? [p.stalled.label] : [])].join(" · ");
+}
+function undispatchedProjectionLine(p) {
+    return [
+        p.taskId,
+        MISSING_EVIDENCE,
+        ...(keptWhenUndispatched(p.blocker, UNRECORDED_BLOCKER) ? [readLabel(p.blocker)] : []),
+        ...(keptWhenUndispatched(p.nextAction, UNRECORDED_NEXT) ? [readLabel(p.nextAction)] : []),
+        ...(p.stalled ? [p.stalled.label] : []),
+    ].join(" · ");
+}
+/**
+ * Rows the projection panel paints: each task's clause at its own wrapped height (OBS-1193). A
+ * never-dispatched clause is shorter than the field line it replaces, so the block is shorter too;
+ * the shell's content counter reads that real height and the pinned run frames record it.
+ */
+function projectionBlockRows(projections, wrap) {
+    return projections.flatMap((p) => wrap(projectionLine(p)).map((line, i) => ({
+        key: `${p.taskId}:${i}`,
+        line,
+        strong: p.stalled !== undefined && i === 0,
+    })));
+}
 /** The Run body: the approved board (BD-1) over the fold, then the selected task's detail panels. */
 export function RunView({ snapshot, rows, page, graph, decisions, session, columns, run, now = Date.now }) {
     const inner = Math.max(1, Math.floor(columns) - 4);
@@ -383,9 +428,21 @@ export function RunView({ snapshot, rows, page, graph, decisions, session, colum
     const { menu, confirming, receipt, notice } = session.decisions;
     const blocked = task === undefined ? [] : graph?.tasks.filter((g) => g.deps.includes(task.id)).map((g) => g.id) ?? decision?.blocks ?? [];
     const board = renderBoardLines({ runId: run.runId, snapshot, graph, now: now(), live: run.live, selection: task?.id, keys: false, colour }, width);
-    return (_jsxs(Box, { flexDirection: "column", width: columns, children: [_jsx(BodyText, { emphasis: "dim", children: fitCells(`RUN / ${snapshot.lifecycle} · ${runSummaryLine(snapshot)}`, width) }), board.map((line, i) => _jsx(BodyText, { children: line || " " }, `${i}:${line}`)), tasks.length === 0 && _jsx(BodyText, { children: fitCells("no tasks recorded — no plan", width) }), task !== undefined && (_jsxs(Panel, { title: `SELECTED / ${task.id}${task.title ? ` · ${task.title}` : ""}`, children: [wrap(`state ${parkOf(task)} · ${attemptLabel(task)} · dispatches ${task.dispatches} · path ${task.path ?? "unknown"} · pane ${task.pane ?? "unknown"} · alarm ${task.alarmMs === undefined ? "unknown" : `${task.alarmMs}ms`}${task.mergeEvidence ? ` · merged #L${task.mergeEvidence.line}` : ""} · locator ${(() => { const l = paneLocator(task, allRows, run.runId); return l.status === "recorded" ? `recorded ${l.reason}` : `unavailable — ${l.reason}`; })()}`).map((line, i) => _jsx(BodyText, { children: line }, `${i}:${line}`)), _jsx(BodyText, { emphasis: "dim", children: fit(`outcome filter ${session.outcomeFilter} (x cycles) · ${shown.length} of ${cells.length} gates shown`) }), shown.map((c) => (_jsx(BodyText, { children: fit(`${c.letter} ${c.gate.padEnd(10)} ${c.labels.join(" · ")}${c.line === undefined ? "" : ` · #L${c.line}`}`) }, c.gate)))] })), projections.length > 0 && (_jsx(Panel, { title: "PROJECTION / every task \u00B7 identity \u00B7 phase \u00B7 build \u00B7 blocker \u00B7 next action, each with its journal line", children: projections.flatMap((p) => wrap(projectionLine(p)).map((line, i) => _jsx(BodyText, { emphasis: p.stalled && i === 0 ? "strong" : "normal", children: line }, `${p.taskId}:${i}`))) })), verdictCell !== undefined && (_jsxs(Panel, { title: `VERDICT / ${verdictCell.gate}${verdictCell.line === undefined ? "" : ` #L${verdictCell.line}`} · ${verdict.length === 0 ? "no verdict text" : `lines ${from + 1}–${from + window.length} of ${verdict.length}`}`, children: [window.map((line, i) => _jsx(BodyText, { children: fit(`${String(from + i + 1).padStart(4)} ${line}`) }, `${from + i}:${line}`)), _jsx(BodyText, { emphasis: "dim", children: fit("←→ gate · PageUp/PageDown page") })] })), task?.state === "human" && (_jsx(Panel, { title: `PARK / ${task.id}`, children: decision === undefined
+    return (_jsxs(Box, { flexDirection: "column", width: columns, children: [_jsx(BodyText, { emphasis: "dim", children: fitCells(`RUN / ${snapshot.lifecycle} · ${runSummaryLine(snapshot)}`, width) }), board.map((line, i) => _jsx(BodyText, { children: line || " " }, `${i}:${line}`)), tasks.length === 0 && _jsx(BodyText, { children: fitCells("no tasks recorded — no plan", width) }), task !== undefined && (_jsxs(Panel, { title: `SELECTED / ${task.id}${task.title ? ` · ${task.title}` : ""}`, children: [wrap(`state ${parkOf(task)} · ${attemptLabel(task)} · dispatches ${task.dispatches} · path ${task.path ?? "unknown"} · pane ${task.pane ?? "unknown"} · alarm ${task.alarmMs === undefined ? "unknown" : `${task.alarmMs}ms`}${task.mergeEvidence ? ` · merged #L${task.mergeEvidence.line}` : ""} · locator ${(() => { const l = paneLocator(task, allRows, run.runId); return l.status === "recorded" ? `recorded ${l.reason}` : `unavailable — ${l.reason}`; })()}`).map((line, i) => _jsx(BodyText, { children: line }, `${i}:${line}`)), _jsx(BodyText, { emphasis: "dim", children: fit(`outcome filter ${session.outcomeFilter} (x cycles) · ${shown.length} of ${cells.length} gates shown`) }), shown.map((c) => (_jsx(BodyText, { children: fit(`${c.letter} ${c.gate.padEnd(10)} ${c.labels.join(" · ")}${c.line === undefined ? "" : ` · #L${c.line}`}`) }, c.gate)))] })), projections.length > 0 && (_jsx(Panel, { title: "PROJECTION / every task \u00B7 identity \u00B7 phase \u00B7 build \u00B7 blocker \u00B7 next action, each with its journal line", children: projectionBlockRows(projections, wrap).map((row) => _jsx(BodyText, { emphasis: row.strong ? "strong" : "normal", children: row.line }, row.key)) })), verdictCell !== undefined && (_jsxs(Panel, { title: `VERDICT / ${verdictCell.gate}${verdictCell.line === undefined ? "" : ` #L${verdictCell.line}`} · ${verdict.length === 0 ? "no verdict text" : `lines ${from + 1}–${from + window.length} of ${verdict.length}`}`, children: [window.map((line, i) => _jsx(BodyText, { children: fit(`${String(from + i + 1).padStart(4)} ${line}`) }, `${from + i}:${line}`)), _jsx(BodyText, { emphasis: "dim", children: fit("←→ gate · PageUp/PageDown page") })] })), task?.state === "human" && (_jsx(Panel, { title: `PARK / ${task.id}`, children: decision === undefined
                     ? _jsx(BodyText, { children: fit("park evidence unavailable — refresh before deciding") })
                     : (_jsxs(_Fragment, { children: [wrap(`#L${decision.park.line} ${decision.park.kind ?? "unknown kind"}${decision.park.failedGate ? ` · failed gate ${decision.park.failedGate}` : ""} · ${decision.park.reason ?? "no reason recorded"}`).map((line, i) => _jsx(BodyText, { children: line }, `park:${i}`)), _jsx(BodyText, { children: fit(`blocks ${blocked.length === 0 ? "nothing" : blocked.join(", ")} · attempts ${decision.attempts}`) }), wrap(decision.verbs.length === 0 ? `diagnostic: ${decision.diagnostic ?? "no verb"}` : `decisions: ${decision.verbs.join(" · ")} (a Actions)`).map((line, i) => _jsx(BodyText, { children: line }, `verbs:${i}`)), _jsx(BodyText, { emphasis: "dim", children: fit(run.live ? "matching live daemon enacts a release at its next task boundary" : run.blockingRunId ? `other live run ${run.blockingRunId} holds the lock; resume after it ends` : "no live owner: a release records permission; resume dispatches") })] })) })), menu !== null && (_jsx(Panel, { title: `ACTIONS / ${menu.taskId}`, focused: true, children: menu.verbs.length === 0
                     ? _jsx(BodyText, { children: fit(`no decision — ${decision?.diagnostic ?? "no verb for this park"}`) })
                     : menu.verbs.map((verb, i) => _jsx(BodyText, { emphasis: i === menu.selection ? "strong" : "normal", children: fit(`${i === menu.selection ? `${GLYPHS.pointer} ` : "  "}${verb}`) }, verb)) })), confirming !== null && (_jsx(Panel, { title: `CONFIRM ${confirming.command.verb.toUpperCase()}`, focused: true, children: decisionLines(decisionConfirmLines(confirming)).map((line, i) => _jsx(BodyText, { children: line }, `${i}:${line}`)) })), receipt !== null && (_jsx(Panel, { title: receipt.ok ? "RECEIPT · appended" : "RECEIPT · refused", children: decisionLines(decisionReceiptLines(receipt)).map((line, i) => _jsx(BodyText, { children: line }, `${i}:${line}`)) })), notice !== null && _jsx(BodyText, { children: notice }), _jsx(BodyText, { emphasis: "dim", children: clipBoard(boardFooter([...RUN_VIEW_KEYS, decisionKeybar(session.decisions, decision)].filter(Boolean), colour), width) })] }));
 }
+// OBS-1178: a refused or unsound decision released and satisfied nothing, so neither the projections nor
+// a gate cell's satisfied label read it; the one decision fold judges every row by its physical line.
+function undecidedLines(rows) {
+    const ordered = rows.filter((r) => r.event !== undefined).sort((a, b) => a.line - b.line);
+    const effective = effectiveDecisions(ordered.map((r) => withPhysicalLine(r.event, r.line)));
+    return new Set(ordered.filter((r) => r.event.event === "task-approved" && !effective.has(r.line)).map((r) => r.line));
+}
+/** Readable rows in physical-line order, minus the decisions that are not effective. */
+function decidedRows(rows) {
+    const undecided = undecidedLines(rows);
+    return rows.filter((r) => r.event !== undefined && !undecided.has(r.line)).sort((a, b) => a.line - b.line);
+}

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

@@ -71,6 +71,10 @@ export type ParkedDecision = {
      * so it is drawn read-only and neither verb is offered on it.
      */
     readonly tombstone: boolean;
+    /** OBS-1178: the park's `<line>@<ts>` token — the confirmed write binds to it via `--park`. */
+    readonly park?: string;
+    /** OBS-1202: a stall park's recorded reap failure — the one stall park recheck may release. */
+    readonly reapFailure?: string;
 };
 /** The parks a verb can release — the rows the surface draws live verbs on. */
 export declare function actionableDecisions(decisions: readonly ParkedDecision[]): readonly ParkedDecision[];
@@ -80,6 +84,8 @@ export type SetupDecisionVerb = "approve" | "waive" | "uphold" | "recheck";
 export type SetupDecisionCommand = {
     readonly verb: SetupDecisionVerb;
     readonly taskId: string;
+    /** OBS-1178: the park token the confirm inset displayed — approve refuses it once a newer park opens. */
+    readonly park?: string;
 };
 /** What the journal file gained this session — one entry per confirmed write. */
 export type SetupDecisionWrite = {

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

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { cloneElement, createElement, useState, } from "react";
 import { parse } from "yaml";
 import { approvalDispositionForRelease, approvalEnactment, approvalRunOwner, approve, } from "../../cli/commands/approve.js";
-import { ATTEMPT_CAP_RELEASE, GATE_SATISFIED_RELEASE, Journal, RECHECK_RELEASE, REVIEW_UPHELD_RELEASE, } from "../../run/journal.js";
+import { ATTEMPT_CAP_RELEASE, bindingToken, GATE_SATISFIED_RELEASE, Journal, RECHECK_RELEASE, REVIEW_UPHELD_RELEASE, } from "../../run/journal.js";
 import { BANNER, GLYPHS, PLAIN_BANNER, } from "../../brand.js";
 import { DEFAULT_CONFIG, INTEGRITY_FLOOR_SHAPES, TIER_RANK, TickmarkrConfigSchema, unifiedYamlDiff, } from "../../config/config.js";
 import { GATE_NAMES, SHAPES } from "../../graph/schema.js";
@@ -576,7 +576,7 @@ function failedGateForNewestPark(events, taskId, parkedIndex) {
 }
 export function deriveParkedDecisions(journal) {
     const statuses = journal.replayStatuses();
-    const events = journal.read();
+    const { events, lines } = journal.readSourced();
     const decisions = [];
     for (const [taskId, status] of statuses) {
         if (status !== "human")
@@ -606,6 +606,8 @@ export function deriveParkedDecisions(journal) {
             attempts,
             failedGate,
             tombstone: isTombstonePark(kind, reason),
+            ...(typeof parked?.ts === "string" ? { park: bindingToken({ line: lines[parkedIndex], ts: parked.ts }) } : {}),
+            ...(kind === "stall" && typeof parked?.data.reapFailure === "string" ? { reapFailure: parked.data.reapFailure } : {}),
         });
     }
     return decisions;
@@ -622,6 +624,9 @@ export function initialSetupDecisionsSession() {
 export function setupDecisionVerbs(decision) {
     if (decision.tombstone)
         return [];
+    // OBS-1202: the production table's census-recovery row; an ordinary stall stays approve-only.
+    if (decision.kind === "stall" && decision.reapFailure !== undefined)
+        return ["approve", "recheck"];
     if (decision.kind !== "gate-fail")
         return ["approve"];
     if (decision.failedGate === undefined)
@@ -677,7 +682,7 @@ export function applySetupDecisionsKey(session, event, parked) {
             session: {
                 ...session,
                 selection,
-                confirming: { verb, taskId: decision.taskId },
+                confirming: { verb, taskId: decision.taskId, ...(decision.park === undefined ? {} : { park: decision.park }) },
             },
         };
     }
@@ -704,6 +709,7 @@ export async function executeSetupDecision(command, { cwd, runId, by }) {
             runId,
             command.taskId,
             ...decisionFlag(command.verb),
+            ...(command.park === undefined ? [] : ["--park", command.park]),
             "--by",
             by,
         ], cwd);
@@ -800,6 +806,7 @@ function decisionEffectLines(command, decision, run) {
 export function setupDecisionConfirmLines(command, decision, actor, journalFile, run) {
     return [
         `task   ${command.taskId}${decision === undefined ? "" : ` · ${decision.kind} · attempt ${decision.attempts}`}`,
+        ...(command.park === undefined ? [] : [`park   ${command.park} · bound; refused if a newer park opens`]),
         `actor  ${actor}`,
         ...decisionEffectLines(command, decision, run),
         `file   ${journalFile} · append only`,

package/dist/tui/ink/fleet-app.d.ts

@@ -1,11 +1,13 @@
 import { type AuthHealth, type WorkerAdapter } from "../../adapters/types.js";
 import { type DenyScopeKey, type InitialDenyProps, type MapEntry, type RoutingMode, type StagedDenyKey, type Tier, type TickmarkrConfig } from "../../config/config.js";
-import { type Shape } from "../../graph/schema.js";
+import { type Effort, type Shape } from "../../graph/schema.js";
 export type FleetSteeringKey = "review" | "consult";
 export type FleetEditorState = Record<DenyScopeKey, string[]> & {
     /** OBS-1046: the staged routing.allow complement, distinct from the authored deny lists above */
     allowOut?: string[];
     classifications: FleetClassification[];
+    /** OBS-1182: staged launch effort per adapter → model; absent = the CLI's own default */
+    efforts?: Record<string, Record<string, Effort>>;
     selectedMode: RoutingMode;
     map: Record<string, MapEntry>;
     judgeSeat?: {
@@ -22,6 +24,8 @@ export type FleetOverlayReview = {
     after: string;
     diff: string;
     path: string;
+    /** OBS-1144: dead pool entries the written config would carry, each with its reason. */
+    notes?: string[];
 };
 export type FleetEditorResult = {
     kind: "write";
@@ -121,11 +125,13 @@ export type FleetStagedRouting = {
     ok: false;
     error: string;
 };
-export declare function FleetApp({ ageMs, agents, initialAllowOut, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, stagedRouting, entry, initialJudge, judgeSeats, viewRows, frameColumns, frameRows, ...initialDenyProps }: InitialDenyProps & {
+export declare function FleetApp({ ageMs, agents, initialAllowOut, initialEfforts, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewAdvisories, reviewOverlay, reloadGuard, stagedRouting, entry, initialJudge, judgeSeats, viewRows, frameColumns, frameRows, ...initialDenyProps }: InitialDenyProps & {
     ageMs: number | null;
     agents: AgentCli[];
     /** OBS-1046: adapter ids and adapter:model keys routing.allow leaves out of the fleet */
     initialAllowOut?: string[];
+    /** OBS-1182: configured launch effort per adapter → model */
+    initialEfforts?: Record<string, Record<string, Effort>>;
     modelGroups: FleetModelGroup[];
     initialMode: RoutingMode;
     modeOptions: FleetModeOption[];
@@ -140,6 +146,8 @@ export declare function FleetApp({ ageMs, agents, initialAllowOut, modelGroups,
     preferOptionsForShape: (shape: Shape, current: string[]) => string[];
     initialSteering: Record<FleetSteeringKey, string[] | undefined>;
     steeringOptionsFor: (which: FleetSteeringKey, current: string[]) => string[];
+    /** OBS-1052(3): advisory review no-verdict history lines — display only, never a routing input */
+    reviewAdvisories?: string[];
     reviewOverlay: (state: FleetEditorState) => FleetOverlayReview;
     reloadGuard: (bytes: string) => string | null;
     /** the routing policy the staged deny sets load as (fleet: the config loader over the candidate
@@ -157,12 +165,14 @@ export declare function FleetApp({ ageMs, agents, initialAllowOut, modelGroups,
     /** terminal height — set only on a real TTY so the footer sticks to the bottom */
     frameRows?: number;
 }): import("react").JSX.Element;
-export declare function runFleetInkEditor({ ageMs, adapters, health, initialAllowOut, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, stagedRouting, entry, initialJudge, judgeSeats, initialInput, input, output, debug, ...initialDenyProps }: InitialDenyProps & {
+export declare function runFleetInkEditor({ ageMs, adapters, health, initialAllowOut, initialEfforts, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewAdvisories, reviewOverlay, reloadGuard, stagedRouting, entry, initialJudge, judgeSeats, initialInput, input, output, debug, ...initialDenyProps }: InitialDenyProps & {
     ageMs: number | null;
     adapters: WorkerAdapter[];
     health: Record<string, AuthHealth>;
     /** OBS-1046: adapter ids and adapter:model keys routing.allow leaves out of the fleet */
     initialAllowOut?: string[];
+    /** OBS-1182: configured launch effort per adapter → model */
+    initialEfforts?: Record<string, Record<string, Effort>>;
     modelGroups: FleetModelGroup[];
     initialMode: RoutingMode;
     modeOptions: FleetModeOption[];
@@ -177,6 +187,8 @@ export declare function runFleetInkEditor({ ageMs, adapters, health, initialAllo
     preferOptionsForShape: (shape: Shape, current: string[]) => string[];
     initialSteering: Record<FleetSteeringKey, string[] | undefined>;
     steeringOptionsFor: (which: FleetSteeringKey, current: string[]) => string[];
+    /** OBS-1052(3): advisory review no-verdict history lines — display only, never a routing input */
+    reviewAdvisories?: string[];
     reviewOverlay: (state: FleetEditorState) => FleetOverlayReview;
     reloadGuard: (bytes: string) => string | null;
     /** the routing policy the staged deny sets load as (fleet: the config loader over the candidate