tickmarkr 2.5.6 → 2.5.7

package/dist/run/protocol.js

@@ -12,6 +12,38 @@ const TaskIdSchema = NonEmptyStringSchema;
 const TaskIdsSchema = z.array(TaskIdSchema);
 const AttemptSchema = z.number().int().nonnegative();
 const EvidenceSchema = z.record(z.string(), z.unknown());
+/** Shared lifecycle vocabulary for shell evidence and later build-result emitters. */
+export const COMMAND_RECEIPT_OUTCOMES = [
+    "started", "completed", "spawn-failed", "timed-out", "cancelled", "reused-result", "skipped", "refused",
+];
+export const CommandReceiptAttributionSchema = z.object({
+    runId: NonEmptyStringSchema,
+    taskId: TaskIdSchema,
+    attempt: AttemptSchema,
+    gateRound: z.number().int().nonnegative(),
+    invocation: NonEmptyStringSchema,
+}).strict();
+export const ShellReceiptSchema = z.object({
+    outcome: z.enum(COMMAND_RECEIPT_OUTCOMES),
+    confirmedStart: z.boolean(),
+    attribution: CommandReceiptAttributionSchema.optional(),
+    pid: z.number().int().positive().optional(),
+    exitCode: z.number().int().nullable().optional(),
+    signal: NonEmptyStringSchema.nullable().optional(),
+    error: z.string().optional(),
+    durationMs: z.number().nonnegative().optional(),
+}).strict();
+/** A task-build row must carry the entire caller-owned correlation, even before spawn. */
+export const CommandReceiptSchema = ShellReceiptSchema.extend({
+    attribution: CommandReceiptAttributionSchema,
+});
+export function readCommandReceipt(raw) {
+    const parsed = CommandReceiptSchema.safeParse(raw);
+    return parsed.success ? { kind: "receipt", receipt: parsed.data } : {
+        kind: "protocol-issue", raw,
+        issues: parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`),
+    };
+}
 /** The T31 outcome vocabulary, made executable and strict at the persistence boundary. */
 export const GateOutcomeSchema = z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("passed") }).strict(),

package/dist/tui/cockpit/board.d.ts

@@ -1,5 +1,6 @@
 import { type RunGraph } from "../../graph/schema.js";
 import type { OperatorSnapshot } from "../../run/operator-state.js";
+import type { AttemptHarvest, TaskRow } from "./derive.js";
 /** The prototype's palette (tasks-redesign.mjs:24-30): xterm-256 indices, stated once. */
 export declare const BOARD_PALETTE: {
     readonly chrome: 238;
@@ -49,6 +50,8 @@ export interface BoardInput {
     /** Footer key hints, joined the prototype's way; `false` leaves the footer to the caller (see boardFooter). */
     readonly keys?: readonly string[] | false;
     readonly colour?: boolean;
+    /** The cockpit's derived rows: the shared projection (blocker, next action, harvest) rides on each board row, unrendered. */
+    readonly rows?: readonly TaskRow[];
 }
 /** One task row, in the parts the Run view recomposes per width band. */
 export interface BoardRow {
@@ -63,6 +66,12 @@ export interface BoardRow {
     readonly note: string;
     /** The note's segments, so a band can wrap it across continuation rows without cutting one. */
     readonly noteParts: readonly string[];
+    /** From the shared projection (derive.ts TaskRow.summary), when the caller supplied rows. */
+    readonly blocker?: string;
+    readonly nextAction?: string;
+    readonly permittedActions?: readonly string[];
+    /** OBS-1048: the newest recorded attempt's harvest evidence, when the caller supplied rows. */
+    readonly harvest?: AttemptHarvest;
 }
 export interface BoardFrame {
     /** Header through the gate header rule, in the prototype's order. */

package/dist/tui/cockpit/board.js

@@ -89,6 +89,15 @@ export function areasFor(files) {
 const hm = (ms) => `${Math.floor(ms / 3.6e6)}h${String(Math.floor((ms % 3.6e6) / 6e4)).padStart(2, "0")}m`;
 const ago = (ms) => (ms < 6e4 ? "just now" : ms < 3.6e6 ? `${Math.round(ms / 6e4)}m ago` : `${Math.round(ms / 3.6e6)}h ago`);
 const isDone = (t) => t !== undefined && (t.merged || t.state === "completed");
+const projected = (row) => {
+    const blocker = row?.summary?.blocker;
+    const harvest = row?.harvests?.at(-1);
+    return {
+        ...(blocker ? { blocker: blocker.kind, permittedActions: blocker.permittedActions } : {}),
+        ...(blocker?.nextAction ? { nextAction: blocker.nextAction } : {}),
+        ...(harvest ? { harvest } : {}),
+    };
+};
 /** The prototype's frame, sectioned. `renderBoard` joins it row for row. */
 export function boardFrame(input, width) {
     const W = Math.max(1, Math.floor(width));
@@ -218,6 +227,7 @@ export function boardFrame(input, width) {
             tail: `  ${pad(mute(sliceCells(t?.channel ?? "—", CHAN - 2).head), CHAN)}${pad(mute(String(attempts)), 5)}`,
             note: note.join(mute(" · ")),
             noteParts: note,
+            ...projected(input.rows?.find((row) => row.taskId === g.id)),
         });
     }
     const bottom = [];

package/dist/tui/cockpit/derive.d.ts

@@ -1,4 +1,6 @@
 export { readOperatorState as deriveOperatorState } from "../../run/operator-state.js";
+import { type TaskActivityProjection } from "../../run/activity.js";
+import { type OperatorTaskSummary } from "../../run/operator-summary.js";
 import type { ComponentState, JournalRow, StatusStripItem } from "./components.js";
 import type { RunViewId } from "./views.js";
 export declare const SPARKLINE_BUCKET_WINDOW = 12;
@@ -60,8 +62,34 @@ export type CockpitGraph = {
         readonly id: string;
         readonly title?: string;
         readonly status?: string;
+        /** Prerequisites and declared gates: read only by the shared projection (blocker, readiness). */
+        readonly deps?: readonly string[];
+        readonly gates?: readonly string[];
     }[];
 };
+/** One recorded seat: a task attempt in a role. Keyed by all three, never by provider alone. */
+export type RecordedIdentity = {
+    readonly key: string;
+    readonly role: string;
+    readonly attempt: number;
+    /** The slot name the driver recorded, verbatim; absent when the row named none. */
+    readonly name?: string;
+};
+/**
+ * OBS-1048: what the journal recorded about one in-flight attempt's harvest. `trailerFirstSeenAt`
+ * is always absent — no producer journals it (daemon.ts samples the trailer without recording;
+ * OBS-1048 add.1, 2.5.8) — and is never synthesized from any other timestamp.
+ */
+export type AttemptHarvest = {
+    readonly attempt: number;
+    readonly lastWorkerStatus?: string;
+    readonly nudgeFailures: number;
+    readonly lastNudgeFailureAt?: string;
+    readonly pageCount: number;
+    readonly trailerFirstSeenAt?: undefined;
+    /** SUSPECTED: nudges failed and pages fired, and no worker-result of THIS attempt followed the launch. */
+    readonly suspectedStalledHarvest: boolean;
+};
 /** How an unrecorded field draws: the engagement said nothing, so the row says nothing. */
 export declare const ABSENT_FIELD = "-";
 /**
@@ -105,6 +133,13 @@ export type TaskRow = {
      * that earns one rather than having to read `done` as if it were the same.
      */
     readonly merged?: true;
+    /** Evidence-only activity projection (run/activity.ts), the one status renders. */
+    readonly activity?: TaskActivityProjection;
+    /** Operator summary (phase, blocker, next action) — the same projection status renders. */
+    readonly summary?: OperatorTaskSummary;
+    readonly identities?: readonly RecordedIdentity[];
+    /** Per recorded attempt, newest last (OBS-1048). */
+    readonly harvests?: readonly AttemptHarvest[];
 };
 /** One recorded gate result. `details` is the record's own text, verbatim. */
 export type GateRow = {

package/dist/tui/cockpit/derive.js

@@ -1,7 +1,13 @@
 // Consolidated C1/C6 readers use the incremental lifecycle contract; legacy captures keep their API.
 export { readOperatorState as deriveOperatorState } from "../../run/operator-state.js";
 import { channelKey } from "../../adapters/types.js";
+import { newestPark, permittedDecisionVerbs } from "../../cli/commands/approve.js";
+import { parseOwnedName } from "../../drivers/types.js";
+import { projectActivity } from "../../run/activity.js";
 import { isPidLive } from "../../run/lock.js";
+import { normalizeGateOutcome } from "../../run/outcome.js";
+import { projectOperatorSummary } from "../../run/operator-summary.js";
+import { trackJournalRows } from "../../run/protocol.js";
 export const SPARKLINE_BUCKET_WINDOW = 12;
 const MINUTE_MS = 60_000;
 const SPARKLINE_BUCKET_WIDTH_LADDER_MINUTES = [
@@ -470,7 +476,133 @@ function journalRows(events, tasks, defects, runStatus) {
  * graph's own `status` is never consulted, which is what keeps a recompiled
  * graph from repainting a parked task green.
  */
-function taskRows(events, tasks, graph) {
+const stringField = (data, key) => typeof data[key] === "string" ? data[key] : undefined;
+const attemptField = (data) => typeof data.attempt === "number" && Number.isInteger(data.attempt) && data.attempt >= 0 ? data.attempt : undefined;
+/** Recorded seats for one task: role and attempt from the row, or from an owned slot name it carries. */
+function recordedIdentities(events, taskId) {
+    const seen = new Map();
+    for (const event of events) {
+        if (event.taskId !== taskId)
+            continue;
+        const slot = recordValue(event.data.slot);
+        const name = stringField(event.data, "slotName") ?? (slot ? stringField(slot, "name") : stringField(event.data, "slot"));
+        const owned = name === undefined ? null : parseOwnedName(name);
+        const role = stringField(event.data, "role") ?? owned?.role ?? (event.event === "worker-launch" ? "worker" : undefined);
+        if (role === undefined)
+            continue;
+        const attempt = attemptField(event.data) ?? owned?.attempt;
+        if (attempt === undefined)
+            continue;
+        const key = `${taskId}:${attempt}:${role}`;
+        if (!seen.has(key))
+            seen.set(key, { key, role, attempt, ...(name === undefined ? {} : { name }) });
+    }
+    return [...seen.values()];
+}
+/**
+ * OBS-1048 fold, chronological: each worker-launch opens a fresh occurrence of its attempt label
+ * (labels reset on resume), and only a worker-result recorded AFTER that launch retires it — an
+ * unnumbered result binds to the newest launch so far, a numbered one to its own attempt's launch.
+ */
+function attemptHarvests(events, taskId) {
+    const byAttempt = new Map();
+    let newest;
+    for (const [order, event] of events.entries()) {
+        if (event.taskId !== taskId)
+            continue;
+        const attempt = attemptField(event.data) ?? (event.event === "worker-result" ? newest : undefined);
+        if (attempt === undefined)
+            continue;
+        const existing = byAttempt.get(attempt);
+        if (event.event === "worker-launch") {
+            // A launch resets its label's evidence: an earlier occurrence's status, nudges, pages and result are history.
+            byAttempt.set(attempt, { launched: true, returned: false, nudges: 0, pages: 0, order });
+            newest = attempt;
+            continue;
+        }
+        const h = existing ?? { launched: false, returned: false, nudges: 0, pages: 0, order };
+        if (!existing)
+            byAttempt.set(attempt, h);
+        switch (event.event) {
+            case "worker-status":
+                h.status = stringField(event.data, "status");
+                break;
+            case "worker-nudge-failed":
+                h.nudges += 1;
+                h.nudgeAt = event.ts;
+                break;
+            case "operator-page":
+                h.pages += 1;
+                break;
+            case "worker-result":
+                h.returned = true;
+                break;
+        }
+    }
+    // Attempt labels reset on resume, so numeric order is not chronology. The board reads the
+    // last harvest as newest; retain the order of each label's latest worker-launch occurrence.
+    return [...byAttempt].sort(([, a], [, b]) => a.order - b.order).map(([attempt, h]) => ({
+        attempt,
+        ...(h.status === undefined ? {} : { lastWorkerStatus: h.status }),
+        nudgeFailures: h.nudges,
+        ...(h.nudgeAt === undefined ? {} : { lastNudgeFailureAt: h.nudgeAt }),
+        pageCount: h.pages,
+        suspectedStalledHarvest: h.launched && !h.returned && h.nudges > 0 && h.pages > 0,
+    }));
+}
+/**
+ * The shared, evidence-only projection status renders (status.ts recordProjection), folded here
+ * so both surfaces read one fact. Phase/blocker/next-action come from run/activity.ts and
+ * run/operator-summary.ts; decisions from the production park oracle.
+ */
+function projectSummaries(events, runId, identities, graph, rowState) {
+    const journal = events.map((event) => ({
+        ts: event.ts, event: event.event, ...(event.taskId === undefined ? {} : { taskId: event.taskId }), data: event.data,
+    }));
+    const graphTask = (id) => graph?.tasks.find((task) => task.id === id);
+    const tasks = identities.map(({ id }) => ({
+        id, gates: graphTask(id)?.gates ?? [], deps: graphTask(id)?.deps ?? [], status: rowState(id) ?? graphTask(id)?.status ?? "unknown",
+    }));
+    const activity = projectActivity(runId, trackJournalRows(runId, journal.map((raw, sourceIndex) => ({ raw, sourceIndex }))), tasks);
+    const rehashAt = journal.reduce((at, event, index) => event.event === "graph-rehash" ? index : at, -1);
+    const summaryTasks = tasks.map((task) => {
+        const evidence = journal.filter((event) => event.taskId === task.id);
+        const last = evidence.at(-1);
+        const recorded = activity.get(task.id);
+        let phase = last ? recorded.state : undefined;
+        // A completed battery is evidence of readiness, never evidence that merge started (status.ts).
+        const boundary = journal.reduce((index, event, at) => ["run-start", "run-resume", "run-end"].includes(event.event)
+            || (event.taskId === task.id && (event.event === "task-dispatch"
+                || (event.event === "phase-start" && event.data.phase === "gates"))) ? at : index, -1);
+        const latest = new Map();
+        journal.forEach((event, index) => {
+            if (event.taskId === task.id && event.event === "gate-result" && typeof event.data.gate === "string")
+                latest.set(event.data.gate, index);
+        });
+        const priorGraph = rehashAt >= 0 && [...latest.values()].some((index) => index < rehashAt);
+        // Latest outcome including non-verdicts (status.ts): a held screen or skipped gate is not a pass.
+        const passedNow = (gate) => {
+            const latestResult = journal.slice(boundary + 1).filter((event) => event.taskId === task.id && event.event === "gate-result" && event.data.gate === gate).at(-1);
+            return latestResult !== undefined && normalizeGateOutcome(latestResult.data).kind === "passed";
+        };
+        if (recorded.state === "unconfirmed" && task.gates.length > 0 && !priorGraph && task.gates.every(passedNow)) {
+            phase = "awaiting merge phase";
+        }
+        const responsibility = [...evidence].reverse().find((event) => typeof event.data.role === "string" || typeof event.data.agent === "string");
+        return {
+            id: task.id, deps: task.deps, status: task.status, phase, lastEvidenceAt: last?.ts,
+            responsible: responsibility ? {
+                role: stringField(responsibility.data, "role"), agent: stringField(responsibility.data, "agent"),
+            } : undefined,
+        };
+    });
+    const decisions = summaryTasks.flatMap((task) => {
+        const park = task.status === "human" ? newestPark(journal, task.id) : undefined;
+        return park ? [{ taskId: task.id, park, verbs: permittedDecisionVerbs(park) }] : [];
+    });
+    return { activity, summaries: new Map(projectOperatorSummary(summaryTasks, decisions).map((task) => [task.taskId, task])) };
+}
+function taskRows(events, tasks, graph, runId) {
     const lastSeen = new Map();
     for (const event of events) {
         if (event.taskId !== undefined)
@@ -483,6 +615,15 @@ function taskRows(events, tasks, graph) {
             id,
             title: undefined,
         }));
+    // `task-done` records completion; only `merge` records landing. The fixed
+    // Tasks-view consumer maps `done` to a check, so the derived row must keep
+    // an unmerged completion in the neutral `completed` state and reserve
+    // `done` for a fact whose merge the journal actually carries.
+    const rowState = (id) => {
+        const fact = tasks.get(id);
+        return fact?.state === "done" && fact.merged !== true ? "completed" : fact?.state;
+    };
+    const projection = projectSummaries(events, runId, identities, graph, rowState);
     return identities.map(({ id, title }) => {
         const fact = tasks.get(id);
         const assignment = fact?.dispatches.at(-1)?.assignment;
@@ -491,13 +632,9 @@ function taskRows(events, tasks, graph) {
         // zero when a run resumes, so a task dispatched 0,1,0 was tried three times
         // and reporting its last label would say one.
         const attempts = fact?.dispatches.length ?? 0;
-        // `task-done` records completion; only `merge` records landing. The fixed
-        // Tasks-view consumer maps `done` to a check, so the derived row must keep
-        // an unmerged completion in the neutral `completed` state and reserve
-        // `done` for a fact whose merge the journal actually carries.
-        const state = fact?.state === "done" && fact.merged !== true
-            ? "completed"
-            : fact?.state;
+        const state = rowState(id);
+        const recorded = recordedIdentities(events, id);
+        const harvests = attemptHarvests(events, id);
         return {
             id: `task:${id}`,
             taskId: id,
@@ -513,6 +650,10 @@ function taskRows(events, tasks, graph) {
             // Landing is its own fact. `done` is work finished; only a recorded merge
             // is work landed, and only that earns a check-mark.
             ...(fact?.merged === true ? { merged: true } : {}),
+            activity: projection.activity.get(id),
+            summary: projection.summaries.get(id),
+            ...(recorded.length === 0 ? {} : { identities: recorded }),
+            ...(harvests.length === 0 ? {} : { harvests }),
         };
     });
 }
@@ -737,9 +878,10 @@ export function deriveRunCockpitData(source, binaryVersion, options = {}) {
                     : interrupted
                         ? "interrupted"
                         : "running";
+    const runId = source.fileName.replace(/(?:\.interrupted)?\.journal\.jsonl$/, "");
     return {
         binaryVersion,
-        runId: source.fileName.replace(/(?:\.interrupted)?\.journal\.jsonl$/, ""),
+        runId,
         branch: typeof start.data.branch === "string" ? start.data.branch : "unknown",
         status: runStatus,
         elapsed: elapsedReading(events[0].ts, events.at(-1).ts),
@@ -762,7 +904,7 @@ export function deriveRunCockpitData(source, binaryVersion, options = {}) {
             ? `${spotlight.id} · ${spotlight.phase} · attempt ${taskAttempt(spotlight)} · ${taskActor(spotlight)}`
             : "- · pending · attempt 1 · unassigned",
         journalRows: journalRows(events, tasks, defects, runStatus),
-        taskRows: taskRows(events, tasks, options.graph),
+        taskRows: taskRows(events, tasks, options.graph, runId),
         gateRows: gateRows(events),
         fleetRows: fleetRows(events),
         statusItems: [

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

@@ -1,6 +1,7 @@
 import { type ReactElement } from "react";
 import type { ChannelCost } from "../../report/cost.js";
 import { type OperatorRecordRow } from "../../report/operator-record.js";
+import { type OperatorPageGroup } from "../../run/operator-page-summary.js";
 import type { EvidenceIdentity } from "../../run/operator-state.js";
 import { type JournalEvent } from "../../run/journal.js";
 import { type ComponentState } from "./components.js";
@@ -49,6 +50,7 @@ export interface EvidenceViewInput {
     readonly learningPreview?: readonly string[];
 }
 export interface EvidenceViewModel {
+    readonly operatorPages: readonly OperatorPageGroup[];
     readonly journal: readonly EvidenceRow[];
     readonly channels: readonly OperatorRecordRow[];
     readonly reportLines: readonly string[];

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/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