tickmarkr 2.5.4 → 2.5.5

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

@@ -9,7 +9,8 @@ import { render, useInput, useStdin } from "ink";
 import { useLayoutEffect, useSyncExternalStore } from "react";
 import { createLiveStore } from "./live-store.js";
 import { HomeView, deriveHomeView, selectNeedsYouTarget } from "./home-view.js";
-import { RunView, applyRunViewKey, initialRunViewSession, runGateCells, evidenceLookup, runTaskRow, GATE_CELL_LETTERS } from "./run-view.js";
+import { RunView, applyRunViewKey, initialRunViewSession, runGateCells, evidenceLookup } from "./run-view.js";
+import { renderBoardLines, stripBoardAnsi } from "./board.js";
 import { EvidenceView, deriveEvidenceView, defaultExportPath, planEvidenceExport, writeEvidenceExport } from "./evidence-view.js";
 import { ShellGridFlow, ShellJournalSelection } from "./components.js";
 import { CockpitShell, initialShellState } from "./shell.js";
@@ -18,12 +19,11 @@ import { shellBindings } from "./keys.js";
 import { createPointerReportReader, POINTER_TRACKING_ON, POINTER_TRACKING_OFF } from "./pointer.js";
 import { deriveRunDecisions, previewDecision, executeDecision, withDecisionPreview, withDecisionReceipt, decisionConfirmLines } from "./decision-actions.js";
 import { approvalRunOwner } from "../../cli/commands/approve.js";
-import { GATE_NAMES } from "../../graph/schema.js";
 import { GLYPHS } from "../../brand.js";
 import { Journal } from "../../run/journal.js";
-import { observeNamedRun } from "../../run/supervision.js";
+import { observeNamedRun, WATCH_OWNER_ENV } from "../../run/supervision.js";
 import { formatOwnedName } from "../../drivers/types.js";
-import { cellWidth, fitCells, wrapCells } from "./width.js";
+import { cellWidth, wrapCells } from "./width.js";
 import { resolveShellColourMode } from "./theme.js";
 let timelineUsers = 0;
 let timelineObserver;
@@ -100,7 +100,10 @@ export async function runConsolidatedCockpit(options) {
         const source = store;
         if (options.observeRun !== false)
             observation = observeNamedRun(cwd, runId, options.environment);
-        let state = { ...initialShellState(), view: options.initialView ?? "home" };
+        // BD-1 (RULING-231-19 §2): the daemon-placed board carries the watch owner token and mounts
+        // rail-less — a zero shortcut budget the plan honours at every width. The manual cockpit keeps its rail.
+        const railless = Boolean((options.environment ?? process.env)[WATCH_OWNER_ENV]);
+        let state = { ...initialShellState(), view: options.initialView ?? "home", ...(railless ? { shortcutColumns: 0 } : {}) };
         let runSession = initialRunViewSession();
         if (options.initialParks) {
             runSession = { ...runSession, selection: Math.max(0, source.snapshot().operator.tasks.findIndex(t => t.state === "human" || t.state === "blocked")) };
@@ -172,6 +175,29 @@ export async function runConsolidatedCockpit(options) {
             state = { ...state, overlay: [result.status === "focused" ? `Focused ${task.id}` : `Pane ${result.status}`, result.reason, "Enter opens task evidence after Esc"], overlayOffset: 0 };
             publish();
         };
+        // The board is taller than a small body; a selection moved by keys or a park opened from Home
+        // scrolls the shell's viewport just far enough that the selected row (and the rows that wrap
+        // under it) is seen. The rows are the very lines the Run view draws at this body width.
+        const followSelection = () => {
+            const snap = source.snapshot();
+            const task = snap.operator.tasks[runSession.selection];
+            if (!task)
+                return;
+            const g = geometry();
+            const lines = renderBoardLines({ runId, snapshot: snap.operator, graph: snap.graph.value, now: (options.now ?? Date.now)(), selection: task.id, keys: false, colour: false }, g.bodyColumns);
+            const first = lines.findIndex(l => l.startsWith("  ❯ "));
+            if (first < 0)
+                return;
+            let last = first;
+            while (last + 1 < lines.length && lines[last + 1].startsWith(" ".repeat(9)))
+                last++;
+            const top = first + 1, bottom = last + 1; // the RUN summary line sits above the board
+            const scroll = state.scroll;
+            if (top < scroll)
+                state = { ...state, scroll: top };
+            else if (bottom >= scroll + g.bodyRows)
+                state = { ...state, scroll: bottom - g.bodyRows + 1 };
+        };
         const openDetail = () => {
             const snap = source.snapshot();
             const task = state.view === "run" ? snap.operator.tasks[runSession.selection] : undefined;
@@ -189,6 +215,7 @@ export async function runConsolidatedCockpit(options) {
         // from the snapshot. The guard prevents the shell from dispatching its echo.
         let leafInput;
         let forwarding = false;
+        let lastRawInput = "";
         const forwardLeaf = (bytes) => {
             forwarding = true;
             try {
@@ -347,12 +374,15 @@ export async function runConsolidatedCockpit(options) {
                     const task = snap.operator.tasks[runSession.selection];
                     const cells = task ? runGateCells(task, evidenceLookup(snap.journal.history, source.page)) : [];
                     runSession = applyRunViewKey(runSession, event, { tasks: snap.operator.tasks, decisions, verdictLines: cells[runSession.verdictGate]?.verdict.length ?? 0 }).session;
+                    if (k.upArrow || k.downArrow)
+                        followSelection();
                     if (k.pageDown || k.pageUp)
                         state = {
                             ...state,
-                            // The Run leaf owns verdict paging; the shell only moves its
-                            // viewport far enough for that leaf's verdict panel to be seen.
-                            scroll: k.pageDown ? geometry().bodyRows : 0,
+                            // The Run leaf owns verdict paging; the shell only moves its viewport so that leaf's
+                            // verdict panel is seen — it sits below the board and the selected task's cells, so the
+                            // viewport goes to the leaf's end (clamped by the shell), not one page down.
+                            scroll: k.pageDown ? Number.MAX_SAFE_INTEGER : 0,
                         };
                     if (runSession.decisions.menu)
                         state = { ...state, overlay: ["Actions — Enter reviews; Esc cancels", ...runSession.decisions.menu.verbs], overlayOffset: 0 };
@@ -501,16 +531,35 @@ export async function runConsolidatedCockpit(options) {
             useSyncExternalStore(listener => { listeners.add(listener); return () => { listeners.delete(listener); }; }, () => revision);
             const stdinContext = useStdin();
             useLayoutEffect(() => {
-                leafInput = stdinContext.internal_eventEmitter;
-                return () => { leafInput = undefined; };
+                const emitter = stdinContext.internal_eventEmitter;
+                leafInput = emitter;
+                // Ink strips an escape sequence's ESC before useInput sees it, so an unnamed CSI and typed
+                // "[..." look alike there. Its parser emits every escape sequence as its own event, so the RAW
+                // event says which it was. Registered in a layout effect, this listener runs before useInput's.
+                const raw = (data) => { lastRawInput = data; };
+                emitter?.on("input", raw);
+                return () => { leafInput = undefined; emitter?.off("input", raw); };
             }, [stdinContext.internal_eventEmitter]);
             const renderedView = state.view;
             const leafActive = state.editor === undefined && !state.overlay && !state.help && !state.reviewing;
             useInput((text, k) => {
                 if (forwarding || (leafActive && renderedView !== "run" && (k.return || (renderedView === "evidence" && text === "e"))))
                     return;
+                // OBS-1002: Ink hands a coalesced chunk ("a\r", "na\r" — a paste, key repeat under load, a
+                // `pane run` message) to the handler as ONE string with no key flags, and a single-key map
+                // ignores it. Split every non-escape chunk into one event per code point; an escape sequence
+                // (arrows, page keys) is one key and already carries its flags.
+                const flagged = k.ctrl || k.meta || k.upArrow || k.downArrow || k.leftArrow || k.rightArrow || k.pageUp || k.pageDown || k.return || k.escape || k.tab || k.backspace || k.delete;
+                const points = !flagged && !lastRawInput.startsWith("\x1b") && [...text].length > 1 ? [...text] : [text];
                 try {
-                    key({ input: text, key: k }, true);
+                    for (const point of points) {
+                        const event = points.length === 1 ? { input: text, key: k }
+                            : point === "\r" || point === "\n" ? { input: "", key: { return: true } }
+                                : point === "\t" ? { input: "", key: { tab: true } }
+                                    : point === "\x1b" ? { input: "", key: { escape: true } }
+                                        : { input: point, key: { shift: /[A-Z]/.test(point) } };
+                        key(event, true);
+                    }
                 }
                 catch (error) {
                     stop(error);
@@ -564,10 +613,9 @@ export async function runConsolidatedCockpit(options) {
             return _jsx(CockpitShell, { snapshot: options.observeRun === false ? { ...snap, journal: { ...snap.journal, source: "no run/journal.jsonl" } } : snap, state: state, columns: p.columns, rows: p.rows, version: options.binaryVersion, colour: colour, onCommit: plan => {
                     committed = plan;
                     const targets = [];
-                    const taskRows = snap.operator.tasks.map((task, index) => ({
-                        id: task.id,
-                        text: fitCells(`${index === Math.min(runSession.selection, snap.operator.tasks.length - 1) ? `${GLYPHS.pointer} ` : "  "}${runTaskRow(task, GATE_NAMES.map(gate => ({ letter: GATE_CELL_LETTERS[task.gates[gate].state] })))}`, Math.max(1, plan.bodyColumns - 4)),
-                    }));
+                    // A board row opens with the prototype's four-cell indent or the focus marker, then the id;
+                    // the first painted row naming a task is that task's target (the effort fold names it again, later).
+                    const boardRowId = (text) => /^(?: {4}| {2}❯ )(\S+)/u.exec(stripBoardAnsi(text))?.[1];
                     const usedTasks = new Set();
                     for (const row of plan.paintedRows) {
                         if (row.row < plan.bodyRow && (row.text.startsWith("1 Home") || row.text.startsWith("1H"))) {
@@ -599,10 +647,12 @@ export async function runConsolidatedCockpit(options) {
                             continue;
                         }
                         if (state.view === "run") {
-                            const task = taskRows.find(task => !usedTasks.has(task.id) && row.text === task.text);
-                            if (task) {
-                                usedTasks.add(task.id);
-                                targets.push({ ...row, kind: "task", id: task.id });
+                            const drawn = boardRowId(row.text);
+                            // A narrow body clips the row inside a long id; the drawn prefix still names one task.
+                            const id = drawn === undefined ? undefined : (snap.operator.tasks.find(task => task.id === drawn) ?? snap.operator.tasks.find(task => task.id.startsWith(drawn)))?.id;
+                            if (id !== undefined && !usedTasks.has(id)) {
+                                usedTasks.add(id);
+                                targets.push({ ...row, kind: "task", id });
                             }
                         }
                         else {
@@ -625,8 +675,8 @@ export async function runConsolidatedCockpit(options) {
                         }
                     }
                     committedTargets = targets;
-                }, children: state.view === "home" ? _jsx(ShellGridFlow, { width: p.bodyColumns, columns: p.columns < 120 ? 2 : 3, rowHeight: p.rows < 20 ? 1 : p.columns < 120 ? 2 : 3, children: _jsx(HomeView, { width: p.bodyColumns, model: homeModel, focused: focused, onOpenPark: id => { runSession = { ...runSession, selection: Math.max(0, snap.operator.tasks.findIndex(t => t.id === id)) }; state = { ...state, view: "run", scroll: 0 }; publish(); }, onOpenDiagnostic: id => { state = { ...state, overlay: [id], overlayOffset: 0 }; publish(); }, onOpenEvidence: openEvidence, onSelectNeedsYou: reportHomeNeedsYouSelection }, String(homeModel.needsYou.length > 0)) }) :
-                    state.view === "run" ? _jsx(RunView, { snapshot: snap.operator, rows: snap.journal.history, page: source.page, graph: snap.graph.value, decisions: visibleDecisions, session: runSession, columns: p.bodyColumns, run: approvalRunOwner(cwd, runId) }) :
+                }, children: state.view === "home" ? _jsx(ShellGridFlow, { width: p.bodyColumns, columns: p.columns < 120 ? 2 : 3, rowHeight: p.rows < 20 ? 1 : p.columns < 120 ? 2 : 3, children: _jsx(HomeView, { width: p.bodyColumns, model: homeModel, focused: focused, onOpenPark: id => { runSession = { ...runSession, selection: Math.max(0, snap.operator.tasks.findIndex(t => t.id === id)) }; state = { ...state, view: "run", scroll: 0 }; followSelection(); publish(); }, onOpenDiagnostic: id => { state = { ...state, overlay: [id], overlayOffset: 0 }; publish(); }, onOpenEvidence: openEvidence, onSelectNeedsYou: reportHomeNeedsYouSelection }, String(homeModel.needsYou.length > 0)) }) :
+                    state.view === "run" ? _jsx(RunView, { snapshot: snap.operator, rows: snap.journal.history, page: source.page, graph: snap.graph.value, decisions: visibleDecisions, session: runSession, columns: p.bodyColumns, run: approvalRunOwner(cwd, runId), now: options.now }) :
                         _jsx(ShellJournalSelection.Provider, { value: reportEvidenceSelection, children: _jsx(EvidenceView, { width: p.bodyColumns, model: { ...model, journal: evidenceRows }, focusEvidence: selectedEvidence, focused: focused, onExport: beginExport, onSelect: id => { selectedEvidence = id; openDetail(); publish(); } }, `${state.query}:${evidenceNavigation}`) }) });
         }
         app = render(_jsx(App, {}), { stdin, stdout: output, debug: options.debug, exitOnCtrlC: false, patchConsole: false });

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

@@ -1,4 +1,4 @@
-import type { ReactElement } from "react";
+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";
@@ -83,8 +83,8 @@ export declare function applyRunViewKey(session: RunViewSession, event: RunViewK
  * a closed run whose record lacks a bucket says so rather than reading absence as empty.
  */
 export declare function runSummaryLine(s: OperatorSnapshot): string;
-/** One matrix row: id, state, the seven letters in declaration order, the recorded attempt. */
-export declare function runTaskRow(t: OperatorTask, cells: readonly Pick<RunGateCell, "letter">[]): string;
+/** The board's footer keys merged with the cockpit's own — every one of them handled by this view or the shell. */
+export declare const RUN_VIEW_KEYS: readonly string[];
 export interface RunViewProps {
     readonly snapshot: OperatorSnapshot;
     /** Journal rows the store retains (C2 `journal.history`); evidence outside them reaches `page`. */
@@ -95,6 +95,8 @@ export interface RunViewProps {
     readonly session: RunViewSession;
     readonly columns: number;
     readonly run: ApprovalRunOwner;
+    /** The clock the board header reads; injectable so a pinned frame does not drift. */
+    readonly now?: () => number;
 }
-/** The Run body. Every line is measured through the width module; nothing overflows its column. */
-export declare function RunView({ snapshot, rows, page, graph, decisions, session, columns, run }: RunViewProps): ReactElement;
+/** The Run body: the approved board (BD-1) over the fold, then the selected task's detail panels. */
+export declare function RunView({ snapshot, rows, page, graph, decisions, session, columns, run, now }: RunViewProps): ReactElement;

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

@@ -1,9 +1,11 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { Box } from "ink";
+import { useContext } from "react";
 import { GLYPHS } from "../../brand.js";
 import { GATE_NAMES } from "../../graph/schema.js";
 import { normalizeGateOutcome } from "../../run/outcome.js";
-import { BodyText, Panel } from "./components.js";
+import { BOARD_KEYS, boardFooter, clipBoard, renderBoardLines } from "./board.js";
+import { BodyText, Panel, ShellTheme } from "./components.js";
 import { applyDecisionKey, decisionConfirmLines, decisionKeybar, decisionReceiptLines, initialDecisionSession, } from "./decision-actions.js";
 import { fitCells, wrapCells } from "./width.js";
 /** Bounded history first, then the store's page accessor for an evicted line. */
@@ -170,15 +172,13 @@ export function runSummaryLine(s) {
 }
 const attemptLabel = (t) => (t.attempt !== undefined ? `attempt ${t.attempt}` : t.dispatches === 0 ? "never dispatched" : "attempt unknown");
 const parkOf = (t) => (t.state === "human" ? `human · ${t.parkKind ?? "unknown kind"}` : t.state);
-/** One matrix row: id, state, the seven letters in declaration order, the recorded attempt. */
-export function runTaskRow(t, cells) {
-    return `${t.id.padEnd(4)} ${parkOf(t).padEnd(20)} ${cells.map((c) => c.letter).join("  ")}  ${attemptLabel(t)}`;
-}
-const MATRIX_HEADER = `${"Task".padEnd(4)} ${"state".padEnd(20)} ${GATE_NAMES.map((g) => g.slice(0, 2)).join(" ")}  latest attempt`;
-const MATRIX_LEGEND = "P pass · F fail · R running · - not run · D disabled · ? unknown | declaration order, not a timeline · acceptance/review concurrent, optional";
-/** The Run body. Every line is measured through the width module; nothing overflows its column. */
-export function RunView({ snapshot, rows, page, graph, decisions, session, columns, run }) {
+/** 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]];
+/** 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);
+    const colour = useContext(ShellTheme).mode !== "none";
+    const width = Math.max(1, Math.floor(columns));
     const fit = (text) => fitCells(text, inner);
     const decisionLines = (lines) => lines.flatMap((line) => wrapCells(line, inner));
     const lookup = evidenceLookup(rows, page);
@@ -194,9 +194,10 @@ export function RunView({ snapshot, rows, page, graph, decisions, session, colum
     const decision = task === undefined ? undefined : decisions.find((d) => d.taskId === task.id);
     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 ?? [];
-    return (_jsxs(Box, { flexDirection: "column", width: columns, children: [_jsxs(Panel, { title: `RUN / ${snapshot.lifecycle}`, focused: true, children: [_jsx(BodyText, { emphasis: "dim", children: fit(runSummaryLine(snapshot)) }), _jsx(BodyText, { emphasis: "dim", children: fit(`  ${MATRIX_HEADER}`) }), tasks.map((t, i) => (_jsx(BodyText, { emphasis: i === selection ? "strong" : "normal", children: fit(`${i === selection ? `${GLYPHS.pointer} ` : "  "}${runTaskRow(t, GATE_NAMES.map((gate) => ({ letter: GATE_CELL_LETTERS[t.gates[gate].state] })))}`) }, t.id))), tasks.length === 0 && _jsx(BodyText, { children: fit("no tasks recorded — no plan") }), _jsx(BodyText, { emphasis: "dim", children: fit(MATRIX_LEGEND) })] }), task !== undefined && (_jsxs(Panel, { title: `SELECTED / ${task.id}${task.title ? ` · ${task.title}` : ""}`, children: [_jsx(BodyText, { children: fit(`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}` : ""}`) }), _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)))] })), 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
+    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: [_jsx(BodyText, { children: fit(`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}` : ""}`) }), _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)))] })), 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: [_jsx(BodyText, { children: fit(`#L${decision.park.line} ${decision.park.kind ?? "unknown kind"}${decision.park.failedGate ? ` · failed gate ${decision.park.failedGate}` : ""} · ${decision.park.reason ?? "no reason recorded"}`) }), _jsx(BodyText, { children: fit(`blocks ${blocked.length === 0 ? "nothing" : blocked.join(", ")} · attempts ${decision.attempts}`) }), _jsx(BodyText, { children: fit(decision.verbs.length === 0 ? `diagnostic: ${decision.diagnostic ?? "no verb"}` : `decisions: ${decision.verbs.join(" · ")} (a Actions)`) }), _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: fitCells(["↑↓ Task", "←→ Verdict gate", "PgUp/PgDn Page", "x Outcome", decisionKeybar(session.decisions, decision)].filter(Boolean).join(" · "), Math.max(1, Math.floor(columns))) })] }));
+                    : 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) })] }));
 }

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

@@ -1,10 +1,12 @@
 import { type AuthHealth, type WorkerAdapter } from "../../adapters/types.js";
-import type { MapEntry, RoutingMode, Tier } from "../../config/config.js";
+import type { MapEntry, RoutingMode, Tier, TickmarkrConfig } from "../../config/config.js";
 import { type Shape } from "../../graph/schema.js";
 export type FleetSteeringKey = "review" | "consult";
 export type FleetEditorState = {
     denyAdapters: string[];
     denyModels: string[];
+    denyWorkersAdapters: string[];
+    denyWorkersModels: string[];
     classifications: FleetClassification[];
     selectedMode: RoutingMode;
     map: Record<string, MapEntry>;
@@ -56,6 +58,15 @@ export type FleetModelEvidence = {
     probeMs?: number;
     /** OBS-519: doctor's failed model-auth verdict reason — the row must not render like a healthy one */
     unauthed?: string;
+    /** OBS-972/FL-1: a floating alias's resolved concrete model id (e.g. "opus" → "claude-opus-5") */
+    identity?: string;
+};
+/** The four staged deny sets every preview and the staged routing policy are computed from. */
+export type FleetStagedDeny = {
+    adapters: string[];
+    models: string[];
+    workersAdapters: string[];
+    workersModels: string[];
 };
 export type FleetModelGroup = {
     adapter: string;
@@ -99,35 +110,41 @@ export type FleetCandidateOption = {
     };
 };
 export declare function formatDoctorAge(ageMs: number | null): string;
-export declare function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, entry, initialJudge, judgeSeats, viewRows, frameColumns, frameRows, }: {
+export type FleetReach = "in" | "out-workers" | "out-all" | "out-allow" | "unknown";
+/** The staged routing policy, or the loader's refusal of the staged overlay. */
+export type FleetStagedRouting = {
+    ok: true;
+    routing: TickmarkrConfig["routing"];
+} | {
+    ok: false;
+    error: string;
+};
+export declare function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels, initialDenyWorkersAdapters, initialDenyWorkersModels, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, stagedRouting, entry, initialJudge, judgeSeats, viewRows, frameColumns, frameRows, }: {
     ageMs: number | null;
     agents: AgentCli[];
     initialDenyAdapters: string[];
     initialDenyModels: string[];
+    initialDenyWorkersAdapters?: string[];
+    initialDenyWorkersModels?: string[];
     modelGroups: FleetModelGroup[];
     initialMode: RoutingMode;
     modeOptions: FleetModeOption[];
     initialMap: Record<string, MapEntry>;
-    modePreview: (mode: RoutingMode, map: Record<string, MapEntry>, deny: {
-        adapters: string[];
-        models: string[];
-    }) => string[];
-    shapeRows: (mode: RoutingMode, map: Record<string, MapEntry>, deny: {
-        adapters: string[];
-        models: string[];
-    }) => FleetShapeRow[];
-    candidatesForShape: (shape: Shape, mode: RoutingMode, map: Record<string, MapEntry>, deny: {
-        adapters: string[];
-        models: string[];
-    }) => {
+    modePreview: (mode: RoutingMode, map: Record<string, MapEntry>, deny: FleetStagedDeny) => string[];
+    shapeRows: (mode: RoutingMode, map: Record<string, MapEntry>, deny: FleetStagedDeny) => FleetShapeRow[];
+    candidatesForShape: (shape: Shape, mode: RoutingMode, map: Record<string, MapEntry>, deny: FleetStagedDeny) => {
         rows: FleetCandidateOption[];
         excludedNote?: string;
+        ledger?: string[];
     };
     preferOptionsForShape: (shape: Shape, current: string[]) => string[];
     initialSteering: Record<FleetSteeringKey, string[] | undefined>;
     steeringOptionsFor: (which: FleetSteeringKey, current: string[]) => 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
+     * bytes); absent ⇒ the four staged sets alone, with no allowlist */
+    stagedRouting?: (deny: FleetStagedDeny) => FleetStagedRouting;
     entry?: "presets" | "probe";
     /** resolved config judge as "adapter:model" — shown on the (keep default) picker row */
     initialJudge?: string;
@@ -140,36 +157,33 @@ export declare function FleetApp({ ageMs, agents, initialDenyAdapters, initialDe
     /** 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, initialDenyAdapters, initialDenyModels, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, entry, initialJudge, judgeSeats, initialInput, input, output, debug, }: {
+export declare function runFleetInkEditor({ ageMs, adapters, health, initialDenyAdapters, initialDenyModels, initialDenyWorkersAdapters, initialDenyWorkersModels, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, stagedRouting, entry, initialJudge, judgeSeats, initialInput, input, output, debug, }: {
     ageMs: number | null;
     adapters: WorkerAdapter[];
     health: Record<string, AuthHealth>;
     initialDenyAdapters: string[];
     initialDenyModels: string[];
+    initialDenyWorkersAdapters?: string[];
+    initialDenyWorkersModels?: string[];
     modelGroups: FleetModelGroup[];
     initialMode: RoutingMode;
     modeOptions: FleetModeOption[];
     initialMap: Record<string, MapEntry>;
-    modePreview: (mode: RoutingMode, map: Record<string, MapEntry>, deny: {
-        adapters: string[];
-        models: string[];
-    }) => string[];
-    shapeRows: (mode: RoutingMode, map: Record<string, MapEntry>, deny: {
-        adapters: string[];
-        models: string[];
-    }) => FleetShapeRow[];
-    candidatesForShape: (shape: Shape, mode: RoutingMode, map: Record<string, MapEntry>, deny: {
-        adapters: string[];
-        models: string[];
-    }) => {
+    modePreview: (mode: RoutingMode, map: Record<string, MapEntry>, deny: FleetStagedDeny) => string[];
+    shapeRows: (mode: RoutingMode, map: Record<string, MapEntry>, deny: FleetStagedDeny) => FleetShapeRow[];
+    candidatesForShape: (shape: Shape, mode: RoutingMode, map: Record<string, MapEntry>, deny: FleetStagedDeny) => {
         rows: FleetCandidateOption[];
         excludedNote?: string;
+        ledger?: string[];
     };
     preferOptionsForShape: (shape: Shape, current: string[]) => string[];
     initialSteering: Record<FleetSteeringKey, string[] | undefined>;
     steeringOptionsFor: (which: FleetSteeringKey, current: string[]) => 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
+     * bytes); absent ⇒ the four staged sets alone, with no allowlist */
+    stagedRouting?: (deny: FleetStagedDeny) => FleetStagedRouting;
     /** "presets" = init's entry: Esc in the browser is HOME to the preset overlay, not quit */
     entry?: "presets" | "probe";
     initialJudge?: string;