tickmarkr 2.5.6 → 2.5.8

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

@@ -2,10 +2,12 @@ import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-run
 import { existsSync, renameSync, statSync, unlinkSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { Box, useInput } from "ink";
-import { useEffect, useState } from "react";
+import { useEffect, useRef, useState } from "react";
 import { buildOperatorRecord, formatOperatorRecordRow } from "../../report/operator-record.js";
+import { EMPTY_OPERATOR_PAGE_SUMMARY, foldOperatorPages, operatorPageRow } from "../../run/operator-page-summary.js";
 import { formatJournalNarration } from "../../run/journal.js";
 import { BodyText, JournalRowPanel, Panel } from "./components.js";
+import { cellWidth, sliceCells } from "./width.js";
 // review.ts:485 emits `; raw saved: <path>) — failing closed`, the path immediately followed by
 // the message's closing paren — so the capture must stop before a trailing `)`, never swallow it.
 const ARTIFACT_PATTERN = /raw saved:\s*([^\s)]+)/gi;
@@ -64,7 +66,7 @@ export function deriveEvidenceJournal(eventsOrRows, source = "journal.jsonl") {
             time: e.ts,
             state: stateFor(e),
             text: formatJournalNarration(e),
-            fullText: details,
+            fullText: details || JSON.stringify(e.data, null, 2),
             artifacts,
             ...(e.taskId ? { taskId: e.taskId } : {}),
             ...(gate ? { gate } : {}),
@@ -89,6 +91,15 @@ export function deriveEvidenceView(input) {
         ? input.rows.flatMap((r) => (r.event ? [r.event] : []))
         : (input.events ?? []);
     return {
+        operatorPages: foldOperatorPages(EMPTY_OPERATOR_PAGE_SUMMARY, items.flatMap((item, index) => {
+            const tracked = "line" in item;
+            const event = tracked ? item.event : item;
+            if (!event)
+                return [];
+            // The source identifies the owning run; preserve physical lines across malformed rows.
+            const row = operatorPageRow(event, tracked ? item.line : index + 1, tracked ? item.source ?? source : source);
+            return row ? [row] : [];
+        })).groups,
         journal: deriveEvidenceJournal(items, source),
         channels: buildOperatorRecord(events, input.costs ?? []),
         reportLines: input.reportLines ?? [],
@@ -171,6 +182,18 @@ export function EvidenceView({ model, width, focused = true, focusEvidence, onSe
     }, [focusEvidence?.source, focusEvidence?.line]);
     const selectedIndex = model.journal.findIndex((row) => row.evidence.line === selectedLine);
     const selectedRow = selectedIndex >= 0 ? model.journal[selectedIndex] : undefined;
+    // The key handler reads the selection from this ref, never from the render it closed over: ink
+    // re-subscribes the handler in an effect AFTER the frame is drawn, so a key arriving in that
+    // window would act on the previous row while the screen shows the new one (Enter opened the row
+    // above the highlighted one; a second fast arrow lost its step). Render resyncs it; a move
+    // writes it before the state update, so the next key sees the move even with no render between.
+    const lineRef = useRef(selectedLine);
+    lineRef.current = selectedLine;
+    const moveTo = (index) => {
+        const line = model.journal[index].evidence.line;
+        lineRef.current = line;
+        setSelectedLine(line);
+    };
     useInput((input, key) => {
         if (key.leftArrow)
             setTab((t) => TABS[(TABS.indexOf(t) - 1 + TABS.length) % TABS.length]);
@@ -182,23 +205,30 @@ export function EvidenceView({ model, width, focused = true, focusEvidence, onSe
             return;
         if (input === "f")
             setFollow((f) => !f);
+        const current = model.journal.findIndex((row) => row.evidence.line === lineRef.current);
         if (key.upArrow) {
             setFollow(false);
-            const i = Math.max(0, (selectedIndex < 0 ? model.journal.length - 1 : selectedIndex) - 1);
-            setSelectedLine(model.journal[i].evidence.line);
+            moveTo(Math.max(0, (current < 0 ? model.journal.length - 1 : current) - 1));
         }
         if (key.downArrow) {
             setFollow(false);
-            const i = Math.min(model.journal.length - 1, (selectedIndex < 0 ? 0 : selectedIndex) + 1);
-            setSelectedLine(model.journal[i].evidence.line);
+            moveTo(Math.min(model.journal.length - 1, (current < 0 ? 0 : current) + 1));
         }
-        if (key.return && selectedRow && onSelect)
-            onSelect(selectedRow.evidence);
+        if (key.return && current >= 0 && onSelect)
+            onSelect(model.journal[current].evidence);
     }, { isActive: focused });
-    const journalRows = model.journal.map((row) => ({
-        id: row.evidence.id, time: row.time, state: row.state, text: row.text,
-    }));
-    return (_jsxs(Box, { flexDirection: "column", width: width, children: [_jsxs(BodyText, { emphasis: "strong", children: ["EVIDENCE ", TABS.map((t) => (t === tab ? `[${TAB_TITLE[t]}]` : TAB_TITLE[t])).join("  "), tab === "journal" ? `  | Follow ${follow ? "on" : "off"}` : "", selectedRow ? `  | selected ${selectedRow.evidence.id}` : ""] }), tab === "journal" && (_jsxs(_Fragment, { children: [_jsx(JournalRowPanel, { rows: journalRows, selection: selectedIndex >= 0 ? selectedIndex : undefined }), _jsx(Panel, { title: "SELECTED EVIDENCE", children: selectedRow
+    const journalRows = model.journal.map((row) => {
+        // Leave room for physical source references and complete state labels in the narrow body.
+        // The raw row opened with Enter retains the full recorded timestamp.
+        const time = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(row.time) ? row.time.slice(11, 19) : row.time;
+        const text = `#L${row.evidence.line} ${row.text}`;
+        // Reserve the widest state label (18 cells), two separators and the selection pointer.
+        // Bound narration before Yoga lays out the row so long task IDs cannot squeeze state words.
+        const budget = typeof width === "number" ? Math.max(1, width - cellWidth(time) - 22) : undefined;
+        const clipped = budget === undefined || cellWidth(text) <= budget ? text : `${sliceCells(text, budget - 1).head}…`;
+        return { id: row.evidence.id, time, state: row.state, text: clipped };
+    });
+    return (_jsxs(Box, { flexDirection: "column", width: width, children: [_jsxs(BodyText, { emphasis: "strong", children: ["EVIDENCE ", TABS.map((t) => (t === tab ? `[${TAB_TITLE[t]}]` : TAB_TITLE[t])).join("  "), tab === "journal" ? `  | Follow ${follow ? "on" : "off"}` : "", selectedRow ? `  | selected ${selectedRow.evidence.id}` : ""] }), tab === "journal" && (_jsxs(_Fragment, { children: [_jsx(JournalRowPanel, { title: "RAW JOURNAL", rows: journalRows, selection: selectedIndex >= 0 ? selectedIndex : undefined }), _jsx(Panel, { title: "OPERATOR PAGE GROUPS", children: model.operatorPages.length ? model.operatorPages.map((group, index) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(BodyText, { emphasis: "strong", children: [group.taskId, " \u00B7 ", group.park, " \u00B7 ", group.status] }), _jsxs(BodyText, { children: ["first ", group.firstEvidenceAt] }), _jsxs(BodyText, { children: ["last ", group.lastEvidenceAt] }), _jsxs(BodyText, { children: ["visible ", group.observedCount, " \u00B7 suppressed ", group.suppressedCount, group.rawOnly ? " · raw-only (suppression unrecorded)" : ""] }), _jsx(BodyText, { children: "Raw source lines (\u2191\u2193 select, Enter open):" }), group.lines.map(line => _jsxs(BodyText, { children: ["#L", line] }, line))] }, `${group.key}:${index}`))) : _jsx(BodyText, { emphasis: "dim", children: "no operator pages" }) }), _jsx(Panel, { title: "SELECTED EVIDENCE", children: selectedRow
                             ? (_jsxs(_Fragment, { children: [_jsxs(BodyText, { emphasis: "dim", children: ["Original journal ", selectedRow.evidence.id] }), selectedRow.fullText.split("\n").map((line, i) => _jsx(BodyText, { children: line }, i)), _jsxs(BodyText, { emphasis: "dim", children: ["Artifacts: ", selectedRow.artifacts.length ? selectedRow.artifacts.join(", ") : "missing"] })] }))
                             : _jsx(BodyText, { emphasis: "dim", children: "no history" }) })] })), tab === "report" && (_jsx(Panel, { title: "REPORT", children: model.reportLines.length
                     ? model.reportLines.map((line, i) => _jsx(BodyText, { children: line }, i))

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

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { Box, useInput } from "ink";
-import { useLayoutEffect, useState } from "react";
+import { useLayoutEffect, useRef, useState } from "react";
 import { GLYPHS } from "../../brand.js";
 import { BodyText, CockpitGrid, Panel, ProgressMeter, Sparkline, StateGlyph, } from "./components.js";
 import { ABSENT_FIELD, fieldReading } from "./derive.js";
@@ -146,75 +146,90 @@ export function HomeView({ model, width, focused = true, onOpenPark, onOpenDiagn
     const maxOffset = Math.max(0, model.activity.length - 1);
     const maxSelection = Math.max(0, model.activity.length - 1);
     const safeOffset = Math.min(offset, maxOffset);
+    // Keep input ahead of the next render/effect subscription, as in EvidenceView.
+    // Render reconciles the refs with model updates; each move writes before setting state.
+    const sectionRef = useRef(effectiveSection);
+    const needsYouIndexRef = useRef(effectiveNeedsYouIndex);
+    const activityIndexRef = useRef(effectiveActivityIndex);
+    sectionRef.current = effectiveSection;
+    needsYouIndexRef.current = effectiveNeedsYouIndex;
+    activityIndexRef.current = effectiveActivityIndex;
+    const moveSection = (next) => {
+        sectionRef.current = next;
+        setSection(next);
+    };
+    const moveNeedsYou = (index) => {
+        needsYouIndexRef.current = index;
+        setNeedsYouIndex(index);
+        setSelectedNeedsYouId(model.needsYou[index]?.id);
+    };
+    const moveActivity = (index) => {
+        activityIndexRef.current = index;
+        setActivityIndex(index);
+        setSelectedEvidenceId(model.activity[index]?.evidence.id);
+    };
     useInput((_input, key) => {
         if (key.leftArrow && model.needsYou.length > 0) {
-            if (effectiveSection === "needsYou") {
-                const nextIndex = (effectiveNeedsYouIndex + 1) % model.needsYou.length;
-                setNeedsYouIndex(nextIndex);
-                setSelectedNeedsYouId(model.needsYou[nextIndex]?.id);
+            if (sectionRef.current === "needsYou") {
+                const nextIndex = (needsYouIndexRef.current + 1) % model.needsYou.length;
+                moveNeedsYou(nextIndex);
             }
             else {
-                setSection("needsYou");
+                moveSection("needsYou");
             }
         }
         if (key.rightArrow)
-            setSection("activity");
+            moveSection("activity");
         if (key.upArrow) {
-            if (effectiveSection === "needsYou") {
+            if (sectionRef.current === "needsYou") {
                 if (model.needsYou.length > 0) {
-                    const nextIndex = (effectiveNeedsYouIndex - 1 + model.needsYou.length) % model.needsYou.length;
-                    setNeedsYouIndex(nextIndex);
-                    setSelectedNeedsYouId(model.needsYou[nextIndex]?.id);
+                    const nextIndex = (needsYouIndexRef.current - 1 + model.needsYou.length) % model.needsYou.length;
+                    moveNeedsYou(nextIndex);
                 }
             }
             else {
                 if (model.activity.length > 0) {
-                    const nextIndex = Math.max(0, effectiveActivityIndex - 1);
-                    setActivityIndex(nextIndex);
-                    setSelectedEvidenceId(model.activity[nextIndex]?.evidence.id);
+                    const nextIndex = Math.max(0, activityIndexRef.current - 1);
+                    moveActivity(nextIndex);
                 }
             }
         }
         if (key.downArrow) {
-            if (effectiveSection === "needsYou") {
+            if (sectionRef.current === "needsYou") {
                 if (model.needsYou.length > 0) {
-                    const nextIndex = (effectiveNeedsYouIndex + 1) % model.needsYou.length;
-                    setNeedsYouIndex(nextIndex);
-                    setSelectedNeedsYouId(model.needsYou[nextIndex]?.id);
+                    const nextIndex = (needsYouIndexRef.current + 1) % model.needsYou.length;
+                    moveNeedsYou(nextIndex);
                 }
             }
             else {
                 if (model.activity.length > 0) {
-                    const nextIndex = Math.min(maxSelection, effectiveActivityIndex + 1);
-                    setActivityIndex(nextIndex);
-                    setSelectedEvidenceId(model.activity[nextIndex]?.evidence.id);
+                    const nextIndex = Math.min(maxSelection, activityIndexRef.current + 1);
+                    moveActivity(nextIndex);
                 }
             }
         }
         if (key.pageDown) {
             setOffset((o) => Math.max(0, o - HOME_ACTIVITY_VISIBLE_ROWS));
             if (model.activity.length > 0) {
-                const nextIndex = Math.max(0, effectiveActivityIndex - HOME_ACTIVITY_VISIBLE_ROWS);
-                setActivityIndex(nextIndex);
-                setSelectedEvidenceId(model.activity[nextIndex]?.evidence.id);
+                const nextIndex = Math.max(0, activityIndexRef.current - HOME_ACTIVITY_VISIBLE_ROWS);
+                moveActivity(nextIndex);
             }
         }
         if (key.pageUp) {
             setOffset((o) => Math.min(maxOffset, o + HOME_ACTIVITY_VISIBLE_ROWS));
             if (model.activity.length > 0) {
-                const nextIndex = Math.min(maxSelection, effectiveActivityIndex + HOME_ACTIVITY_VISIBLE_ROWS);
-                setActivityIndex(nextIndex);
-                setSelectedEvidenceId(model.activity[nextIndex]?.evidence.id);
+                const nextIndex = Math.min(maxSelection, activityIndexRef.current + HOME_ACTIVITY_VISIBLE_ROWS);
+                moveActivity(nextIndex);
             }
         }
         if (key.return) {
-            if (effectiveSection === "needsYou") {
-                const target = selectedNeedsYou;
+            if (sectionRef.current === "needsYou") {
+                const target = selectNeedsYouTarget(model, needsYouIndexRef.current);
                 if (target)
                     (target.kind === "park" ? onOpenPark : onOpenDiagnostic)(target.id);
             }
             else {
-                const row = model.activity[effectiveActivityIndex];
+                const row = model.activity[activityIndexRef.current];
                 if (row)
                     onOpenEvidence(row.evidence);
             }

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

@@ -121,6 +121,7 @@ export declare function createLiveStore(options: LiveStoreOptions): {
                     oracle: "test";
                     test: string;
                     text?: string | undefined;
+                    landing?: string | undefined;
                 } | {
                     oracle: "judge";
                     text: string;
@@ -138,6 +139,14 @@ export declare function createLiveStore(options: LiveStoreOptions): {
                     confidence?: number | undefined;
                     reason?: string | undefined;
                 }[] | undefined;
+                pins?: ({
+                    kind: "literal";
+                    text: string;
+                    glob: string;
+                } | {
+                    kind: "fixture";
+                    paths: string[];
+                })[] | undefined;
                 routingHints?: {
                     pin?: {
                         via: string;
@@ -213,6 +222,7 @@ export declare function createLiveStore(options: LiveStoreOptions): {
                     oracle: "test";
                     test: string;
                     text?: string | undefined;
+                    landing?: string | undefined;
                 } | {
                     oracle: "judge";
                     text: string;
@@ -230,6 +240,14 @@ export declare function createLiveStore(options: LiveStoreOptions): {
                     confidence?: number | undefined;
                     reason?: string | undefined;
                 }[] | undefined;
+                pins?: ({
+                    kind: "literal";
+                    text: string;
+                    glob: string;
+                } | {
+                    kind: "fixture";
+                    paths: string[];
+                })[] | undefined;
                 routingHints?: {
                     pin?: {
                         via: string;

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

@@ -1,6 +1,6 @@
 import { type ReactElement } from "react";
 import { type JournalRow } from "./components.js";
-import { type RunCockpitData } from "./derive.js";
+import { type RunCockpitData, type TaskRow } from "./derive.js";
 import { type KeybarEntry, type RunInteractionState, type RunKeyProjection } from "./keys.js";
 import { type RunViewId } from "./views.js";
 import { type FramePlan, type FrameRegion, type FrameState, type FrameCockpitLayout, type FrameView, type MeasuredSize, type PlannedFrame } from "./layout.js";
@@ -29,6 +29,13 @@ export declare function panelRows(lines: readonly string[], columns: number): nu
  * identities assigned by the production journal derivation.
  */
 export declare function deriveRunViewRows(data: RunCockpitData, viewId: RunViewId, filterQuery?: string): readonly JournalRow[];
+/**
+ * T9: the shared projection (derive.ts TaskRow.summary/activity/identities/harvests) read onto the
+ * 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.
+ */
+export declare function taskProjectionText(row: TaskRow, journal?: readonly JournalRow[]): string;
 /**
  * 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

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

@@ -4,6 +4,7 @@ import { cloneElement, createContext, useContext, useEffect, useInsertionEffect,
 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 { 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";
@@ -279,7 +280,7 @@ function promotedViewRows(data, viewId) {
             time: fieldReading(row.lastEventTime),
             ...(row.lastEventTimestamp === undefined ? {} : { timestamp: row.lastEventTimestamp }),
             state: taskRowState(row),
-            text: `${row.taskId} · ${fieldReading(row.state)} · ${runAttemptLabel(row.attempts)} · ${fieldReading(row.actor)}${row.title === undefined ? "" : ` · ${row.title}`}`,
+            text: `${row.taskId} · ${fieldReading(row.state)} · ${runAttemptLabel(row.attempts)} · ${fieldReading(row.actor)}${row.title === undefined ? "" : ` · ${row.title}`} · ${taskProjectionText(row, data.journalRows)}`,
         }));
     }
     if (viewId === "gates") {
@@ -302,6 +303,99 @@ function promotedViewRows(data, viewId) {
     }
     return [];
 }
+/**
+ * T9: the shared projection (derive.ts TaskRow.summary/activity/identities/harvests) read onto the
+ * 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.
+ */
+export function taskProjectionText(row, journal = []) {
+    const identity = row.identities?.at(-1);
+    const blocker = row.summary?.blocker;
+    const harvest = row.harvests?.at(-1);
+    const evidence = projectionEvidence(row, journal);
+    const at = (line) => line === undefined ? "(no journal row)" : `#L${line}`;
+    const responsible = row.summary?.responsible;
+    const identityLabel = identity
+        ? `${identity.role} ${fieldReading(identity.name ?? responsible?.agent)}`
+        : responsible?.role !== undefined || responsible?.agent !== undefined
+            ? `${fieldReading(responsible.role)} ${fieldReading(responsible.agent)}`
+            : fieldReading(undefined);
+    return [
+        `identity ${identityLabel}${evidence.identity === undefined ? identityLabel === fieldReading(undefined) ? "" : ` ${at(undefined)}` : ` ${at(evidence.identity)}`}`,
+        `phase ${fieldReading(row.summary?.phase ?? row.activity?.state)}${row.summary?.phase === undefined && row.activity === undefined ? "" : ` ${at(evidence.phase)}`}`,
+        `build ${fieldReading(row.activity?.build.state)}${row.activity !== undefined && "receipt" in row.activity.build ? ` ${at(evidence.build)}` : ""}`,
+        `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}`);
+}
+/**
+ * Correlate each already-derived field with the row that can have produced that value. This is
+ * intentionally not a "newest row with a plausible name" lookup: launch identity is paired by
+ * recorded seat, phase starts at the current launch boundary, a receipt is taken from the current
+ * verification battery, and harvest counts select only the number of rows retained by that fold.
+ * The newest presentation row omits its event name; it is used only for a terminal field whose
+ * derived last-evidence timestamp proves that exact row is the transition.
+ */
+function projectionEvidence(row, journal) {
+    const facts = journal.flatMap((entry) => {
+        const match = /^event:(\d+)$/u.exec(entry.id);
+        if (!match || !entry.text.startsWith(`${row.taskId} `))
+            return [];
+        const separator = entry.text.lastIndexOf(" · ");
+        return [{ line: Number(match[1]), timestamp: entry.timestamp, event: separator < 0 ? undefined : entry.text.slice(separator + 3) }];
+    }).sort((a, b) => a.line - b.line);
+    const lines = (event) => facts.filter((fact) => fact.event === event).map((fact) => fact.line);
+    // JournalRow is deliberately presentation-only: it carries neither the raw payload nor its
+    // attempt. Consequently two plausible rows cannot be correlated to the accepted projection
+    // without guessing. Fail closed in that case; the evidence remains reachable in the journal.
+    const only = (candidates) => candidates.length === 1 ? candidates[0] : undefined;
+    const unknownAfter = (line) => facts
+        .filter((fact) => fact.event === undefined && (line === undefined || fact.line > line))
+        .map((fact) => fact.line);
+    const newestTaskLine = [...facts].reverse().find((fact) => fact.timestamp === row.lastEventTimestamp)?.line;
+    const namedIdentities = row.identities?.filter((seat) => seat.name !== undefined) ?? [];
+    const currentIdentity = row.identities?.at(-1);
+    const launches = lines("worker-launch");
+    const identityIndex = currentIdentity === undefined ? -1 : namedIdentities.findIndex((seat) => seat.key === currentIdentity.key);
+    // A newest worker-launch has no printed event suffix. It is nevertheless the only missing launch
+    // when the identity fold gained one more named seat on the row carrying lastEventTimestamp.
+    if (launches.length < namedIdentities.length && newestTaskLine !== undefined && !launches.includes(newestTaskLine))
+        launches.push(newestTaskLine);
+    const identity = identityIndex >= 0 && launches.length === namedIdentities.length
+        ? launches[identityIndex]
+        : currentIdentity === undefined ? only(lines("worker-result")) : undefined;
+    const launch = identityIndex >= 0 && launches.length === namedIdentities.length ? launches[identityIndex] : undefined;
+    const afterLaunch = (candidates) => candidates.filter((line) => launch === undefined || line > launch);
+    const state = row.summary?.phase ?? row.activity?.state;
+    let phase;
+    if (state === "terminal") {
+        phase = only([...lines("task-human"), ...lines("task-failed"), ...lines("task-done"), ...lines("task-approved"), ...lines("merge")].sort((a, b) => a - b));
+    }
+    else if (state === "implementing")
+        phase = launch;
+    else if (state === "preparing")
+        phase = only([...lines("task-dispatch"), ...unknownAfter(undefined)]);
+    else if (state === "returned-for-verification")
+        phase = only([...afterLaunch(lines("worker-result")), ...unknownAfter(launch)]);
+    else if (state === "validating" || state === "reviewing")
+        phase = only([...afterLaunch([...lines("phase-start"), ...lines("gate-phase-start")].sort((a, b) => a - b)), ...unknownAfter(launch)]);
+    else
+        phase = only([...afterLaunch([...lines("gate-result"), ...lines("phase-start"), ...lines("gate-phase-start")].sort((a, b) => a - b)), ...unknownAfter(launch)]);
+    const battery = lines("phase-start").at(-1) ?? launch;
+    const receiptLines = [...lines("build-receipt"), ...lines("build-result")].sort((a, b) => a - b).filter((line) => battery === undefined || line > battery);
+    const build = row.activity !== undefined && "receipt" in row.activity.build ? only([...receiptLines, ...unknownAfter(battery)]) : undefined;
+    const parkCandidates = [...lines("task-human"), ...lines("task-failed")].sort((a, b) => a - b);
+    const park = only(parkCandidates) ?? (parkCandidates.length === 0 && row.state === "human" ? newestTaskLine : undefined);
+    const nudgeCandidates = afterLaunch(lines("worker-nudge-failed"));
+    const pageCandidates = afterLaunch(lines("operator-page"));
+    const nudgeCount = row.harvests?.at(-1)?.nudgeFailures ?? 0;
+    const pageCount = row.harvests?.at(-1)?.pageCount ?? 0;
+    const nudge = nudgeCount > 0 && nudgeCandidates.length === nudgeCount ? nudgeCandidates.at(-1) : undefined;
+    const page = pageCount > 0 && pageCandidates.length === pageCount ? pageCandidates.at(-1) : undefined;
+    return { identity, phase, build, ...(row.summary?.blocker ? { blocker: park, nextAction: park } : {}), launch, nudge, page };
+}
 /** A task row exists on an operator surface only when the journal fold recorded a task fact. */
 function recordedTaskRow(row) {
     return row.state !== undefined

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

@@ -83,6 +83,43 @@ 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 projected reading and the physical journal line it came from; no line means no row says it. */
+export interface ProjectionField {
+    readonly label: string;
+    readonly line?: number;
+}
+export interface TaskProjection {
+    readonly taskId: string;
+    readonly identity: ProjectionField;
+    readonly phase: ProjectionField;
+    readonly build: ProjectionField;
+    readonly blocker: ProjectionField;
+    readonly nextAction: ProjectionField;
+    /** OBS-1048: present only when the newest launched attempt has failed nudges, pages and no worker-result. */
+    readonly stalled?: ProjectionField;
+}
+export declare const STALL_MARKER = "\u26A0 stalled harvest suspected";
+/**
+ * The evidence-only projection status renders (run/activity.ts, run/operator-summary.ts), folded
+ * over the journal rows this view was handed, with the physical line each reading was taken from.
+ * 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. */
+export declare const projectionLine: (p: TaskProjection) => string;
+export interface PaneLocator {
+    readonly status: "recorded" | "unavailable";
+    readonly reason: string;
+    /** The worker-launch row the reading stands on, when one exists. */
+    readonly line?: number;
+}
+/**
+ * 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
+ * chosen by title, provider or task id; a missing, foreign, stale or ambiguous record reads
+ * unavailable with the rows it was read from, and reading never touches a host.
+ */
+export declare function paneLocator(task: OperatorTask, rows: readonly RunEvidenceRow[], runId: string): PaneLocator;
 /** 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 {