tickmarkr 1.83.0 → 1.85.0

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

@@ -1,16 +1,21 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { Box, useApp, useStdout } from "ink";
-import { cloneElement, useInsertionEffect, useMemo, useRef, } from "react";
+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 { fieldReading } from "./derive.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, FULL_JOURNAL_ROWS, planFrame, SIDEBAR_COLUMN_FLOOR, } from "./layout.js";
+import { FRAME_HEADER_GAP, FRAME_NESTED_ROW_BANDS, FULL_JOURNAL_ROWS, planFrame, RUN_PANEL_HORIZONTAL_CHROME, SIDEBAR_COLUMN_FLOOR, } from "./layout.js";
+import { pointerHoverRow, pointerRestingCell, sessionRailOverride, watchPointerRest, watchSessionRailOverride, } from "./pointer.js";
 import { cellWidth, fitCells, wrapCells } from "./width.js";
 export { deriveRunCockpitData } from "./derive.js";
 export { PANEL_CHROME_ROWS } from "./components.js";
-/** The width focus and key routing resolve at. */
+/**
+ * The width focus and key routing resolve at, from a measured width — the form
+ * used before a plan exists. Once one does, `plannedKeyColumns` (pointer.ts)
+ * reads the same answer off the bands the plan actually drew.
+ */
 export function runKeyColumns(columns) {
     return columns >= SIDEBAR_COLUMN_FLOOR
         ? Math.max(columns, RUN_SIDE_RAIL_COLUMN_FLOOR)
@@ -48,35 +53,111 @@ function IdentityHeader({ data, columns, secondary = true, }) {
             {
                 title: "",
                 lines: [
-                    `${data.runId} · ${data.branch}  ${data.status} · ${data.elapsed}`,
+                    frameCaption(data),
                 ],
             },
         ];
         return (_jsxs(Box, { flexDirection: "column", children: [_jsx(NarrowHeaderBand, { columns: columns, content: primary, rightStrong: true }), secondary && (_jsx(NarrowHeaderBand, { columns: columns, content: secondaryBand }))] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(BodyText, { emphasis: "strong", children: lockup[0] ?? "tickmarkr" }), _jsxs(BodyText, { emphasis: "strong", children: ["v", data.binaryVersion, " \u00B7 binary ", GLYPHS.pass] })] }), secondary && (_jsxs(Box, { justifyContent: "space-between", children: [_jsx(BodyText, { emphasis: "strong", children: lockup[1] ?? "tickmarkr" }), _jsxs(BodyText, { children: [data.runId, " \u00B7 ", data.branch, "  ", data.status, " \u00B7 ", data.elapsed] })] }))] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(BodyText, { emphasis: "strong", children: lockup[0] ?? "tickmarkr" }), _jsxs(BodyText, { emphasis: "strong", children: ["v", data.binaryVersion, " \u00B7 binary ", GLYPHS.pass] })] }), secondary && (_jsxs(Box, { justifyContent: "space-between", children: [_jsx(BodyText, { emphasis: "strong", children: lockup[1] ?? "tickmarkr" }), _jsx(BodyText, { children: frameCaption(data) })] }))] }));
 }
 function NarrowHeaderBand({ columns, content, rightStrong = false, }) {
     const widths = allocateBandColumns(columns, content, NARROW_HEADER_ALLOCATION);
     return (_jsxs(CockpitGrid, { columns: columns, columnContents: content, allocation: NARROW_HEADER_ALLOCATION, children: [_jsx(BandLines, { columns: Math.max(1, widths[0]), lines: content[0].lines, emphasis: "strong" }), _jsx(Box, { alignItems: "flex-end", flexDirection: "column", children: _jsx(BandLines, { columns: Math.max(1, widths[1]), lines: content[1].lines, emphasis: rightStrong ? "strong" : "normal" }) })] }));
 }
 const RUN_SIDE_RAIL_WIDTH = 16;
-/** Border plus horizontal padding charged by Panel around its body. */
-const RUN_PANEL_HORIZONTAL_CHROME = 4;
+function runInstant(runId) {
+    const match = runId.match(/\brun-(\d{4})(\d{2})(\d{2})-(\d{2})(\d{2})(\d{2})/u);
+    return match === null
+        ? new Date()
+        : new Date(Number(match[1]), Number(match[2]) - 1, Number(match[3]), Number(match[4]), Number(match[5]), Number(match[6]));
+}
+function utcClock(value) {
+    const match = value.match(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/u);
+    return match === null
+        ? undefined
+        : [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function localZoneLabel(data) {
+    const newestTimestamp = data.journalRows.find((row) => row.timestamp !== undefined)?.timestamp;
+    const recorded = newestTimestamp === undefined ? undefined : new Date(newestTimestamp);
+    const reference = recorded !== undefined && Number.isFinite(recorded.getTime())
+        ? recorded
+        : runInstant(data.runId);
+    const offset = -reference.getTimezoneOffset();
+    if (offset === 0)
+        return "UTC";
+    const sign = offset < 0 ? "-" : "+";
+    const hours = String(Math.floor(Math.abs(offset) / 60)).padStart(2, "0");
+    const minutes = Math.abs(offset) % 60;
+    return minutes === 0
+        ? `${sign}${hours}`
+        : `${sign}${hours}:${String(minutes).padStart(2, "0")}`;
+}
+function localClockTime(value, timestamp) {
+    if (utcClock(value) === undefined)
+        return value;
+    if (timestamp === undefined)
+        return value;
+    const completeInstant = new Date(timestamp);
+    if (!Number.isFinite(completeInstant.getTime()))
+        return value;
+    const hours = String(completeInstant.getHours()).padStart(2, "0");
+    const minutes = String(completeInstant.getMinutes()).padStart(2, "0");
+    const seconds = String(completeInstant.getSeconds()).padStart(2, "0");
+    return `${hours}:${minutes}:${seconds}`;
+}
+/** Name the ruler an already-built caption's bare attempt number is counted on. */
+function nameAttemptRuler(caption) {
+    return caption.replace(/(?<!engagement |run )\battempt (?=\d)/gu, "engagement attempt ");
+}
+/**
+ * The fold owns active-task identity and full event order. This surface only names the attempt
+ * ruler and fits that authoritative caption; TaskRows are never ranked into a competing answer.
+ */
+function engagementProgressCaption(data, columns = Number.POSITIVE_INFINITY) {
+    const caption = nameAttemptRuler(data.progressCaption);
+    if (cellWidth(caption) <= columns)
+        return caption;
+    const actorSeparator = caption.lastIndexOf(" · ");
+    return actorSeparator < 0
+        ? caption
+        : `${caption.slice(0, actorSeparator)} ${caption.slice(actorSeparator + 3)}`;
+}
+function runAttemptLabel(attempts) {
+    return attempts === 1
+        ? "run attempt 1"
+        : `run attempts ${fieldReading(attempts)}`;
+}
 /** The header caption: the run's identity line, planned as the header's refinable sub-region. */
 function frameCaption(data) {
-    return `${data.runId} · ${data.branch} · ${data.status} · ${data.elapsed}`;
+    return `${data.runId} · ${data.branch} · ${data.status} · ${data.elapsed} · zone ${localZoneLabel(data)}`;
 }
 /** The header's fixed left part: brand, version and the two tab labels. */
-function headerLead(data, plan) {
+function headerLead(data, plan, columns) {
     const tabs = plan.tab === "watch"
         ? `[ WATCH ]${FRAME_HEADER_GAP}${DECISIONS_TAB_TITLE}`
         : `WATCH${FRAME_HEADER_GAP}[ ${DECISIONS_TAB_TITLE} ]`;
-    return `tickmarkr ${data.binaryVersion}${FRAME_HEADER_GAP}${tabs}`;
+    if (plan.regions.some((region) => region.id === "caption")) {
+        return `tickmarkr ${data.binaryVersion}${FRAME_HEADER_GAP}${tabs}`;
+    }
+    const withVersion = `tickmarkr ${data.binaryVersion}${FRAME_HEADER_GAP}${tabs} · zone ${localZoneLabel(data)}`;
+    const compactTabs = plan.tab === "watch"
+        ? `[WATCH]${DECISIONS_TAB_TITLE}`
+        : `WATCH[${DECISIONS_TAB_TITLE}]`;
+    const compact = `tickmarkr ${data.binaryVersion}${compactTabs} zone ${localZoneLabel(data)}`;
+    if (cellWidth(withVersion) <= columns)
+        return withVersion;
+    if (cellWidth(compact) <= columns)
+        return compact;
+    const markedTabs = plan.tab === "watch"
+        ? `>WATCH${DECISIONS_TAB_TITLE}`
+        : `WATCH>${DECISIONS_TAB_TITLE}`;
+    return `tickmarkr ${data.binaryVersion}${markedTabs} zone ${localZoneLabel(data)}`;
 }
 /** The one plain header line: brand, version and the two tab labels, the active one marked. */
 function PlannedHeader({ data, plan, columns, }) {
-    return (_jsx(BodyText, { emphasis: "strong", children: fitCells(headerLead(data, plan), Math.max(1, columns)) }));
+    return (_jsx(BodyText, { emphasis: "strong", children: fitCells(headerLead(data, plan, columns), Math.max(1, columns)) }));
 }
 /** The header's caption sub-region: the run identity, right-aligned in it. */
 function PlannedCaption({ data, columns, }) {
@@ -114,7 +195,37 @@ function setupSectionLines(section, data) {
     const parked = data.taskRows.filter((row) => row.state === "human");
     if (parked.length === 0)
         return ["No parked decisions in this engagement"];
-    return parked.map((row) => `${row.taskId} · parked · attempt ${row.attempts ?? 0}`);
+    return parked.map((row) => `${row.taskId} · parked · ${runAttemptLabel(row.attempts)}`);
+}
+/**
+ * The plan's item rows, and the ref the frame registers their painted node
+ * through. Every body panel draws its list into this one box, so the rectangle
+ * the conformance oracle measures off the paint is the rectangle planFrame
+ * planned — which is exactly the pin a field standing beside the plan could
+ * never carry. Absent on the unsized legacy surface, which has no plan.
+ */
+const ItemRowsBand = createContext(undefined);
+/**
+ * The identity of the row a live pointer is resting on, or none. It is drawn
+ * state and only drawn state: nothing reads it back, no interaction state
+ * carries it, and the one provider is fed by a `hover` prop the frame's own
+ * callers supply. A capture supplies none — `capture.ts` builds this frame from
+ * data, size and interaction alone — so every golden, anchor and colour capture
+ * records the pointerless appearance by construction rather than by a guard
+ * stripping a highlight back out afterwards.
+ */
+const HoveredRow = createContext(null);
+/**
+ * A body panel's list, drawn into the plan's own item rows and nowhere else.
+ * The band is consumed by the outermost panel that asks for it — a panel nested
+ * inside that one (the RUN view's own journal) is part of the list, not a second
+ * claim on the region, so the band is cleared for everything below.
+ */
+function ItemRows({ children }) {
+    const band = useContext(ItemRowsBand);
+    if (band === undefined)
+        return _jsx(_Fragment, { children: children });
+    return (_jsx(Box, { ref: band.regionRef, flexDirection: "column", height: band.region.rows, width: band.region.columns, flexShrink: 0, children: _jsx(ItemRowsBand.Provider, { value: undefined, children: children }) }));
 }
 /**
  * The setup tab's body, drawn inside the same row budget the watch tab's views
@@ -156,20 +267,26 @@ export function deriveRunViewRows(data, viewId, filterQuery = "") {
  * drew. The overview owns no list of its own, and the journal is a tail.
  */
 function promotedViewRows(data, viewId) {
+    // Surrendered by identity, never rebuilt: the journal view shows the fold's own records, and
+    // rewriting their text here — even to name the ruler its attempt is counted on — would be this
+    // surface authoring a row. The counters the surface DOES compose (the caption, the task rows)
+    // name their rulers below.
     if (viewId === "journal")
         return data.journalRows;
     if (viewId === "tasks") {
-        return data.taskRows.map((row) => ({
+        return data.taskRows.filter(recordedTaskRow).map((row) => ({
             id: row.id,
             time: fieldReading(row.lastEventTime),
-            state: taskRowState(row.state),
-            text: `${row.taskId} · ${fieldReading(row.state)} · attempt ${fieldReading(row.attempts)} · ${fieldReading(row.actor)}${row.title === undefined ? "" : ` · ${row.title}`}`,
+            ...(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}`}`,
         }));
     }
     if (viewId === "gates") {
         return data.gateRows.map((row) => ({
             id: row.id,
             time: row.time,
+            ...(row.timestamp === undefined ? {} : { timestamp: row.timestamp }),
             state: row.state,
             text: `${fieldReading(row.taskId)} · ${fieldReading(row.gate)} · ${row.pass === undefined ? fieldReading(undefined) : row.pass ? "pass" : "fail"}${row.details === undefined ? "" : ` · ${row.details}`}`,
         }));
@@ -178,19 +295,29 @@ function promotedViewRows(data, viewId) {
         return data.fleetRows.map((row) => ({
             id: row.id,
             time: fieldReading(row.lastEventTime),
+            ...(row.lastEventTimestamp === undefined ? {} : { timestamp: row.lastEventTimestamp }),
             state: "neutral",
             text: `${row.adapter} · ${row.model} · dispatches ${fieldReading(row.dispatches)}`,
         }));
     }
     return [];
 }
+/** A task row exists on an operator surface only when the journal fold recorded a task fact. */
+function recordedTaskRow(row) {
+    return row.state !== undefined
+        || row.lastEventTime !== undefined
+        || row.attempts !== undefined
+        || row.actor !== undefined
+        || row.merged === true
+        || row.parkKind !== undefined;
+}
 /** A task's recorded state read as the component vocabulary the rows draw in. */
-function taskRowState(state) {
-    if (state === "done")
+function taskRowState(row) {
+    if (row.state === "done" && row.merged === true)
         return "pass";
-    if (state === "failed")
+    if (row.state === "failed")
         return "fail";
-    if (state === "running" || state === "human")
+    if (row.state === "running" || row.state === "human")
         return "active";
     return "neutral";
 }
@@ -207,17 +334,47 @@ function windowedRows(rows, bodyRows, selection) {
         ...(selectedIndex < 0 ? {} : { selection: selectedIndex - offset }),
     };
 }
+/**
+ * The identities the body's rows carry in the order the body draws them — the
+ * same window `SizedJournalPanel` paints, so a hit on a body row resolves to
+ * the row an operator is looking at rather than to a position in a collection
+ * the frame scrolled past. A body that draws no selectable list (the overview,
+ * the journal tail, an open detail, the help overlay, the decisions tab) owns
+ * no rows here.
+ */
+export function drawnRunViewRowIds(data, interaction, bodyRows) {
+    if (interaction.tab === "setup"
+        || interaction.activeView === "run"
+        || interaction.opened !== null
+        || interaction.help)
+        return [];
+    const rows = deriveRunViewRows(data, interaction.activeView, interaction.filterQuery);
+    return selectableRunViewRowIds(interaction.activeView, windowedRows(rows, bodyRows, interaction.selection).rows.map((row) => row.id));
+}
 function SizedJournalPanel({ rows, bodyRows, title, selection, focused, }) {
     const window = windowedRows(rows, bodyRows, selection);
+    // The hovered row is carried as its identity, never as a screen row: it was
+    // resolved through the plan once, and this panel finds it in the very window
+    // it is about to paint or does not draw it at all. A list this pointer cell
+    // acts on nothing in — the passive overview tail, the journal's unselectable
+    // rows — finds nothing here, so no row is decorated for being passed over.
+    const hovered = useContext(HoveredRow);
+    const hover = hovered === null
+        ? -1
+        : window.rows.findIndex((row) => row.id === hovered);
     const emptyRows = Math.max(0, bodyRows - window.rows.length);
     const journal = JournalRowPanel({
-        rows: window.rows,
+        rows: window.rows.map((row) => ({
+            ...row,
+            time: localClockTime(row.time, row.timestamp),
+        })),
         title,
         selection: window.selection,
         focused,
+        ...(hover < 0 ? {} : { hover }),
     });
     const journalProps = journal.props;
-    return cloneElement(journal, {}, journalProps.children, emptyRows > 0 ? _jsx(Box, { height: emptyRows }, "journal-space") : null);
+    return cloneElement(journal, {}, _jsxs(ItemRows, { children: [journalProps.children, emptyRows > 0 ? _jsx(Box, { height: emptyRows }, "journal-space") : null] }, "items"));
 }
 /** A body panel (help overlay, opened event) padded to the journal's rows. */
 function SizedLinesPanel({ title, lines, bodyRows, wrapColumns, focused, flexGrow, }) {
@@ -226,7 +383,7 @@ function SizedLinesPanel({ title, lines, bodyRows, wrapColumns, focused, flexGro
         : lines.flatMap((line) => composeBandLine(line, wrapColumns));
     const visible = drawnLines.slice(0, bodyRows);
     const emptyRows = Math.max(0, bodyRows - visible.length);
-    return (_jsxs(Panel, { title: title, focused: focused, flexGrow: flexGrow, children: [visible.map((line, index) => (_jsx(Box, { height: 1, overflow: "hidden", children: _jsx(BodyText, { children: line }) }, `${index}:${line}`))), emptyRows > 0 && _jsx(Box, { height: emptyRows })] }));
+    return (_jsx(Panel, { title: title, focused: focused, flexGrow: flexGrow, children: _jsxs(ItemRows, { children: [visible.map((line, index) => (_jsx(Box, { height: 1, overflow: "hidden", children: _jsx(BodyText, { children: line }) }, `${index}:${line}`))), emptyRows > 0 && _jsx(Box, { height: emptyRows })] }) }));
 }
 /** The lines the help overlay draws: every advertised key and its promise. */
 function helpLines(entries) {
@@ -234,7 +391,7 @@ function helpLines(entries) {
 }
 /** The lines the opened-event view draws for one journal row. */
 function eventLines(row) {
-    return [`${row.time} · ${row.state}`, row.text];
+    return [`${localClockTime(row.time, row.timestamp)} · ${row.state}`, row.text];
 }
 /**
  * A view drawn from the rows its own derivation produces: its detail while the
@@ -246,7 +403,7 @@ function RunViewPanel({ data, viewId, interaction, focused, keyEntries, bodyRows
     const view = runViewById(viewId);
     const rows = deriveRunViewRows(data, viewId, interaction.filterQuery);
     if (interaction.help) {
-        return (_jsx(Panel, { title: "HELP", focused: focused, flexGrow: 1, children: helpLines(keyEntries).map((line) => _jsx(BodyText, { children: line }, line)) }));
+        return (_jsx(Panel, { title: "HELP", focused: focused, flexGrow: 1, children: _jsx(ItemRows, { children: helpLines(keyEntries).map((line) => _jsx(BodyText, { children: line }, line)) }) }));
     }
     const opened = interaction.opened === null
         ? undefined
@@ -255,7 +412,7 @@ function RunViewPanel({ data, viewId, interaction, focused, keyEntries, bodyRows
         return (_jsx(SizedLinesPanel, { title: view.detailTitle, lines: eventLines(opened), bodyRows: bodyRows, wrapColumns: bodyColumns, focused: focused, flexGrow: 1 }));
     }
     if (rows.length === 0) {
-        return (_jsx(Panel, { title: view.title, focused: focused, flexGrow: 1, children: _jsxs(BodyText, { emphasis: "dim", children: ["No ", view.id, " in this engagement"] }) }));
+        return (_jsx(Panel, { title: view.title, focused: focused, flexGrow: 1, children: _jsx(ItemRows, { children: _jsxs(BodyText, { emphasis: "dim", children: ["No ", view.id, " in this engagement"] }) }) }));
     }
     return (_jsx(SizedJournalPanel, { rows: rows, bodyRows: bodyRows, title: interaction.filterPrompt
             ? `${view.title} /${interaction.filterQuery}`
@@ -359,15 +516,15 @@ function TailBand({ data, rows, columns, pendingWrites, }) {
         ? ["PENDING WRITES · none"]
         : deriveRunViewRows(data, "journal")
             .slice(-rows)
-            .map((row) => `${row.time} ${row.text}`);
+            .map((row) => `${localClockTime(row.time, row.timestamp)} ${row.text}`);
     // A styled blank cell differs with colour on and off; these rows carry no dim style.
     return (_jsx(Box, { flexDirection: "column", height: rows, overflow: "hidden", children: Array.from({ length: rows }, (_, index) => (_jsx(Box, { height: 1, overflow: "hidden", children: _jsx(BodyText, { children: fitCells(lines[index] ?? "", columns) }) }, index))) }));
 }
-function ApprovedProgress({ data, caption, }) {
-    return (_jsxs(Panel, { title: "PROGRESS", children: [_jsx(ProgressMeter, { value: data.progress, width: 28 }), caption && _jsx(BodyText, { emphasis: "dim", children: data.progressCaption })] }));
+function ApprovedProgress({ data, caption, columns, }) {
+    return (_jsxs(Panel, { title: "PROGRESS", children: [_jsx(ProgressMeter, { value: data.progress, width: 28 }), caption && _jsx(BodyText, { emphasis: "dim", children: engagementProgressCaption(data, columns) })] }));
 }
-function CompactProgress({ data, caption, meterWidth = 28, }) {
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", flexWrap: "nowrap", children: [_jsx(BodyText, { emphasis: "strong", children: "PROGRESS " }), _jsx(ProgressMeter, { value: data.progress, width: meterWidth })] }), caption && _jsx(BodyText, { emphasis: "dim", children: data.progressCaption })] }));
+function CompactProgress({ data, caption, meterWidth = 28, columns, }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", flexWrap: "nowrap", children: [_jsx(BodyText, { emphasis: "strong", children: "PROGRESS " }), _jsx(ProgressMeter, { value: data.progress, width: meterWidth })] }), caption && _jsx(BodyText, { emphasis: "dim", children: engagementProgressCaption(data, columns) })] }));
 }
 /** The RUN view's interior, allocated out of the planned body span, each element granted whole or not at all. */
 function resolveRunViewContent(bodySpan, bodyColumns, data) {
@@ -390,8 +547,9 @@ function resolveRunViewContent(bodySpan, bodyColumns, data) {
         : 0;
     journal += tail;
     available -= tail;
+    const progressCaptionColumns = Math.max(1, bodyColumns - RUN_PANEL_HORIZONTAL_CHROME);
     const captionRows = progressBar
-        ? wrapCells(data.progressCaption, Math.max(1, bodyColumns)).length
+        ? wrapCells(engagementProgressCaption(data, progressCaptionColumns), progressCaptionColumns).length
         : 0;
     const progressCaption = captionRows > 0 && available >= captionRows;
     if (progressCaption)
@@ -414,12 +572,13 @@ function resolveRunViewContent(bodySpan, bodyColumns, data) {
 }
 /** What fills the regions this paint draws, resolved from the plan's own spans. */
 function resolveRegionContent(plan, data, interaction) {
-    const bodyRegion = requiredRegion(plan, "body");
-    const bodySpan = bodyRegion.rows;
+    const bodySpan = requiredRegion(plan, "body").rows;
     const sideRails = plan.band === "sidebar";
-    const body = Math.max(1, bodySpan - PANEL_CHROME_ROWS);
-    const bodyColumns = Math.max(1, bodyRegion.columns - RUN_PANEL_HORIZONTAL_CHROME);
-    const common = { body, bodyColumns, sideRails };
+    // The plan's own item rows, consumed unmodified: the paint draws its list at
+    // this region and the pointer resolves a hit through it — one geometry.
+    const items = requiredRegion(plan, "items");
+    const bodyColumns = items.columns;
+    const common = { items, sideRails };
     if (interaction.tab !== "setup" && interaction.activeView === "run") {
         return {
             ...common,
@@ -447,15 +606,15 @@ function resolveRegionContent(plan, data, interaction) {
 /** The RUN view drawn at its planned spans: every row budget arrives resolved. */
 function LadderRunPanel({ data, content, compactMeterWidth, interaction, keyEntries, focused = true, }) {
     if (interaction?.help === true) {
-        return (_jsx(SizedLinesPanel, { title: "HELP", lines: helpLines(keyEntries), bodyRows: content.body, wrapColumns: content.bodyColumns, focused: focused, flexGrow: 1 }));
+        return (_jsx(SizedLinesPanel, { title: "HELP", lines: helpLines(keyEntries), bodyRows: content.items.rows, wrapColumns: content.items.columns, focused: focused, flexGrow: 1 }));
     }
-    return (_jsxs(Panel, { title: "RUN", focused: focused, flexGrow: 1, children: [_jsx(RunStats, { data: data, mode: content.stats }), content.progressBar && (content.approvedProgress
-                ? _jsx(ApprovedProgress, { data: data, caption: content.progressCaption })
-                : (_jsx(CompactProgress, { data: data, caption: content.progressCaption, meterWidth: compactMeterWidth }))), content.journal > 0 && (_jsx(JournalBody, { data: data, interaction: interaction, bodyRows: content.journal, keyEntries: keyEntries }))] }));
+    return (_jsx(Panel, { title: "RUN", focused: focused, flexGrow: 1, children: _jsxs(ItemRows, { children: [_jsx(RunStats, { data: data, mode: content.stats }), content.progressBar && (content.approvedProgress
+                    ? (_jsx(ApprovedProgress, { data: data, caption: content.progressCaption, columns: Math.max(1, content.items.columns - RUN_PANEL_HORIZONTAL_CHROME) }))
+                    : (_jsx(CompactProgress, { data: data, caption: content.progressCaption, meterWidth: compactMeterWidth, columns: Math.max(1, content.items.columns - RUN_PANEL_HORIZONTAL_CHROME) }))), content.journal > 0 && (_jsx(JournalBody, { data: data, interaction: interaction, bodyRows: content.journal, keyEntries: keyEntries }))] }) }));
 }
 function LegacyRunPanel({ data, interaction, keyEntries, focused = true, }) {
     const rows = deriveRunViewRows(data, "journal");
-    return (_jsxs(Panel, { title: "RUN", focused: focused, flexGrow: 1, children: [_jsx(RunStats, { data: data, mode: "tiles" }), _jsxs(Panel, { title: "PROGRESS", children: [_jsx(ProgressMeter, { value: data.progress, width: 28 }), _jsx(BodyText, { emphasis: "dim", children: data.progressCaption })] }), _jsx(JournalBody, { data: data, interaction: interaction, bodyRows: rows.length, keyEntries: keyEntries })] }));
+    return (_jsxs(Panel, { title: "RUN", focused: focused, flexGrow: 1, children: [_jsx(RunStats, { data: data, mode: "tiles" }), _jsxs(Panel, { title: "PROGRESS", children: [_jsx(ProgressMeter, { value: data.progress, width: 28 }), _jsx(BodyText, { emphasis: "dim", children: engagementProgressCaption(data) })] }), _jsx(JournalBody, { data: data, interaction: interaction, bodyRows: rows.length, keyEntries: keyEntries })] }));
 }
 /**
  * One planned band, drawn at exactly the span the plan gives it. Unsized (the
@@ -467,8 +626,11 @@ function FrameBand({ rows, row = false, gap, regionRef, children, }) {
 /** A sized sub-floor plan draws the plain fallback, clipped to the measured size. */
 function PlainFallbackPaint({ data, size, }) {
     const columns = Math.max(1, size.columns);
+    // This is an operator surface, so it names its zone once like every other one.
+    // The run.ci/run.non-tty machine anchors are drawn by capture.ts's
+    // defaultPlainRenderer, not by this component, so the label does not move them.
     const lines = [
-        `tickmarkr ${data.binaryVersion}`,
+        `tickmarkr ${data.binaryVersion} · zone ${localZoneLabel(data)}`,
         `${data.runId} ${data.status} ${data.elapsed}`,
         ...data.statusItems.map((item) => item.text),
     ];
@@ -524,14 +686,14 @@ function RunCockpitPaint({ data, columns, plan, content, interaction, keyProject
     const setup = currentInteraction.tab === "setup";
     return (_jsxs(Box, { flexDirection: "column", width: plan.size.columns, height: plan.size.rows, overflow: "hidden", children: [_jsxs(FrameBand, { rows: header.rows, row: true, regionRef: regionRef("header"), children: [_jsx(Box, { flexGrow: 1, flexShrink: 1, height: header.rows, overflow: "hidden", children: _jsx(PlannedHeader, { data: data, plan: plan, columns: plan.size.columns - (caption?.columns ?? 0) }) }), caption !== undefined && (_jsx(Box, { ref: regionRef("caption"), width: caption.columns, height: caption.rows, flexShrink: 0, overflow: "hidden", children: _jsx(PlannedCaption, { data: data, columns: caption.columns }) }))] }), _jsx(FrameBand, { rows: requiredRegion(plan, "rule").rows, regionRef: regionRef("rule"), children: _jsx(RuleBand, { columns: plan.size.columns }) }), strip !== undefined && (_jsx(FrameBand, { rows: strip.rows, regionRef: regionRef("strip"), children: _jsx(ViewStrip, { selection: railSelection, columns: strip.columns }) })), _jsxs(FrameBand, { rows: body.rows, row: true, children: [rail !== undefined && (_jsx(Box, { ref: regionRef("rail"), width: rail.columns, height: rail.rows, flexShrink: 0, overflow: "hidden", children: setup
                             ? (_jsx(SectionsBand, { focused: railFocused, selection: railSelection, columns: rail.columns }))
-                            : (_jsx(RailBand, { data: data, focused: railFocused, selection: railSelection, columns: rail.columns, rows: rail.rows, sidebar: plan.sidebar })) })), _jsx(Box, { ref: regionRef("body"), width: body.columns, height: body.rows, flexShrink: 0, flexDirection: "column", overflow: "hidden", children: setup
-                            ? (_jsx(SetupTabPanel, { data: data, selection: railSelection, focused: contentFocused, keyEntries: keyEntries, help: currentInteraction.help, bodyRows: content.body, bodyColumns: content.bodyColumns }))
-                            : activeView === "run"
-                                ? (_jsx(LadderRunPanel, { data: data, content: content, compactMeterWidth: content.sideRails ? undefined : 24, interaction: currentInteraction, keyEntries: keyEntries, focused: contentFocused }))
-                                : (_jsx(RunViewPanel, { data: data, viewId: activeView, interaction: currentInteraction, focused: contentFocused, keyEntries: keyEntries, bodyRows: content.body, bodyColumns: content.bodyColumns })) })] }), _jsx(FrameBand, { rows: requiredRegion(plan, "rule2").rows, regionRef: regionRef("rule2"), children: _jsx(RuleBand, { columns: plan.size.columns }) }), tail !== undefined && (_jsx(FrameBand, { rows: tail.rows, regionRef: regionRef("tail"), children: _jsx(TailBand, { data: data, rows: tail.rows, columns: tail.columns, pendingWrites: plan.content.tail === "pending-writes" }) })), _jsx(FrameBand, { rows: requiredRegion(plan, "status").rows, regionRef: regionRef("status"), children: _jsx(StatusStrip, { items: reportedStatusItems, width: plan.size.columns }) }), _jsx(FrameBand, { rows: requiredRegion(plan, "keybar").rows, regionRef: regionRef("keybar"), children: _jsx(RunKeybar, { entries: keyEntries, width: plan.size.columns, help: currentInteraction.help }) })] }));
+                            : (_jsx(RailBand, { data: data, focused: railFocused, selection: railSelection, columns: rail.columns, rows: rail.rows, sidebar: plan.sidebar })) })), _jsx(Box, { ref: regionRef("body"), width: body.columns, height: body.rows, flexShrink: 0, flexDirection: "column", overflow: "hidden", children: _jsx(ItemRowsBand.Provider, { value: { region: content.items, regionRef: regionRef("items") }, children: setup
+                                ? (_jsx(SetupTabPanel, { data: data, selection: railSelection, focused: contentFocused, keyEntries: keyEntries, help: currentInteraction.help, bodyRows: content.items.rows, bodyColumns: content.items.columns }))
+                                : activeView === "run"
+                                    ? (_jsx(LadderRunPanel, { data: data, content: content, compactMeterWidth: 24, interaction: currentInteraction, keyEntries: keyEntries, focused: contentFocused }))
+                                    : (_jsx(RunViewPanel, { data: data, viewId: activeView, interaction: currentInteraction, focused: contentFocused, keyEntries: keyEntries, bodyRows: content.items.rows, bodyColumns: content.items.columns })) }) })] }), _jsx(FrameBand, { rows: requiredRegion(plan, "rule2").rows, regionRef: regionRef("rule2"), children: _jsx(RuleBand, { columns: plan.size.columns }) }), tail !== undefined && (_jsx(FrameBand, { rows: tail.rows, regionRef: regionRef("tail"), children: _jsx(TailBand, { data: data, rows: tail.rows, columns: tail.columns, pendingWrites: plan.content.tail === "pending-writes" }) })), _jsx(FrameBand, { rows: requiredRegion(plan, "status").rows, regionRef: regionRef("status"), children: _jsx(StatusStrip, { items: reportedStatusItems, width: plan.size.columns }) }), _jsx(FrameBand, { rows: requiredRegion(plan, "keybar").rows, regionRef: regionRef("keybar"), children: _jsx(RunKeybar, { entries: keyEntries, width: plan.size.columns, help: currentInteraction.help }) })] }));
 }
 /** Resolve every draw-time input; the plan is planFrame's own return, consumed unmodified. */
-export function planRunCockpitFrame({ data, columns, rows, interaction, keyProjection = projectRunKeyEntries, }) {
+export function planRunCockpitFrame({ data, columns, rows, interaction, keyProjection = projectRunKeyEntries, railColumns, }) {
     const suppliedInteraction = interaction ?? initialRunInteractionState();
     const suppliedRows = deriveRunViewRows(data, suppliedInteraction.activeView, suppliedInteraction.filterQuery);
     const rowIds = suppliedRows.map((row) => row.id);
@@ -547,6 +709,7 @@ export function planRunCockpitFrame({ data, columns, rows, interaction, keyProje
         tab: repaired.tab,
         detail: repaired.opened !== null,
         captionCells: cellWidth(frameCaption(data)),
+        ...(railColumns === undefined ? {} : { railColumns }),
     };
     const plan = planFrame(size, view, state);
     const content = rows === undefined || plan.kind !== "frame"
@@ -565,15 +728,56 @@ export function planRunCockpitFrame({ data, columns, rows, interaction, keyProje
     };
 }
 /** The public surface always enters paint through one measured plan. */
-export function RunCockpitFrame({ data, columns, rows, interaction, keyProjection = projectRunKeyEntries, }) {
+export function RunCockpitFrame({ data, columns, rows, interaction, keyProjection = projectRunKeyEntries, onCommittedFrame, }) {
+    // The session's panel resize override, read from the pointer layer the live
+    // drag feeds and redrawn when the boundary moves. It enters the frame only
+    // as an input to this planning call — the drawn frame is the recomputed
+    // plan, so a resize can never paint beside the plan. Nothing persists it: a
+    // relaunch plans the default layout.
+    const railOverride = useSyncExternalStore(watchSessionRailOverride, sessionRailOverride, sessionRailOverride);
     const plannedFrame = useMemo(() => planRunCockpitFrame({
         data,
         columns,
         rows,
         interaction,
         keyProjection,
-    }), [data, columns, rows, interaction, keyProjection]);
-    return (_jsx(RunCockpitFrameFromPlan, { data: data, plannedFrame: plannedFrame }));
+        railColumns: railOverride ?? undefined,
+    }), [data, columns, rows, interaction, keyProjection, railOverride]);
+    useEffect(() => {
+        onCommittedFrame?.(plannedFrame, data);
+    }, [plannedFrame, data, onCommittedFrame]);
+    // Where the pointer is resting, read from the pointer layer that the live
+    // input path feeds and redrawn when it moves. There is no prop beside it: a
+    // hover cannot be handed to this frame at all, only reported to the terminal.
+    const resting = useSyncExternalStore(watchPointerRest, pointerRestingCell, pointerRestingCell);
+    // And only a frame that publishes its geometry for hit testing can be hovered
+    // — publishing it is what makes a pointer report resolve against this frame
+    // at all. A capture publishes none and resolves none, so no golden, anchor or
+    // colour capture can carry a highlight however the pointer came to rest: the
+    // pointerless appearance is what that path draws by construction, not what a
+    // guard strips back out of it.
+    const hover = onCommittedFrame === undefined ? null : resting;
+    const hoveredRow = useMemo(() => {
+        const plan = plannedFrame.plan;
+        if (hover === null || plan.kind !== "frame"
+            || plannedFrame.content === undefined)
+            return null;
+        const interaction = plannedFrame.interaction;
+        // The whole surface a click resolves through, not only the geometry: what a
+        // click at this cell ACTS ON is the highlight's answer, and that route
+        // passes through the focus the frame is drawn with and the rows a key may
+        // stand on. Deriving the highlight from the row lookup alone would advertise
+        // a row of the drawn view while the rail marker stands on another — where
+        // the click opens the marked view and selects nothing.
+        return pointerHoverRow({
+            plan,
+            interaction,
+            drawnRowIds: drawnRunViewRowIds(data, interaction, plannedFrame.content.items.rows),
+            rowIds: selectableRunViewRowIds(interaction.activeView, deriveRunViewRows(data, interaction.activeView, interaction.filterQuery)
+                .map((row) => row.id)),
+        }, hover) ?? null;
+    }, [plannedFrame, data, hover]);
+    return (_jsx(HoveredRow.Provider, { value: hoveredRow, children: _jsx(RunCockpitFrameFromPlan, { data: data, plannedFrame: plannedFrame }) }));
 }
 function requiredRegion(plan, id) {
     const region = plan.regions.find((candidate) => candidate.id === id);
@@ -588,6 +792,21 @@ function assertPlanSpans(plan) {
     let nextRow = 0;
     for (const [id, span] of Object.entries(plan.rowSpans)) {
         const region = requiredRegion(plan, id);
+        const host = FRAME_NESTED_ROW_BANDS[id];
+        if (host !== undefined) {
+            // A nested band refines its host's rows rather than tiling beside them,
+            // so it advances no row cursor — and is held to its span and to staying
+            // inside the band that hosts it.
+            const within = requiredRegion(plan, host);
+            if (region.rows !== span ||
+                region.row < within.row ||
+                region.row + region.rows > within.row + within.rows ||
+                region.column < within.column ||
+                region.column + region.columns > within.column + within.columns) {
+                throw new Error(`planned row region ${id} has offset/span ${region.row}/${region.rows} column ${region.column}/${region.columns}, expected span ${span} inside ${host} at ${within.row}/${within.rows} column ${within.column}/${within.columns}`);
+            }
+            continue;
+        }
         const fullWidth = id !== "body";
         if (region.row !== nextRow ||
             region.rows !== span ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "1.83.0",
+  "version": "1.85.0",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",