tickmarkr 1.84.0 → 1.86.0

package/dist/tui/cockpit/derive.js

@@ -116,6 +116,75 @@ function daemonPid(events) {
     }
     return undefined;
 }
+/**
+ * The state an event writes onto the task it names — the whole list of them, so
+ * "did anything move this task" is asked in one place. `task-dispatch` and
+ * `merge` carry more than a state and are folded by hand below; they are named
+ * here because they move one all the same.
+ *
+ * A Map, because an event name is whatever the journal wrote: an object's own
+ * lookup answers `constructor` and `toString` with something inherited and
+ * truthy, so a line naming one would masquerade as a state transition — writing
+ * a function where a TaskState belongs and releasing a park the run declared.
+ * A Map answers only for the keys stated here.
+ */
+const TASK_STATE_BY_EVENT = new Map([
+    ["task-dispatch", "running"],
+    ["merge", "done"],
+    ["task-done", "done"],
+    ["task-failed", "failed"],
+    ["task-human", "human"],
+    ["task-approved", "pending"],
+]);
+/** Only task identities the summary actually records can enter its fold. */
+function summaryTaskIds(value) {
+    return Array.isArray(value)
+        ? value.filter((id) => typeof id === "string")
+        : [];
+}
+/**
+ * The parks the latest `run-end` says the daemon stopped holding, that nothing
+ * since resolved. The summary is the daemon's own closing statement, so a run
+ * whose end names a task in `human` owes the operator a verb whether or not a
+ * `task-human` line happens to precede it — that dependence is what let a run
+ * end read `done` over a parked task (OBS-252).
+ *
+ * "Since" is measured from the summary forward, and only forward. The summary
+ * describes the moment the daemon exited, so a state written *before* it —
+ * the dispatch it parked, the completion of a round it then held for review —
+ * is history the summary already accounts for and cannot answer it. Weighing
+ * the whole-journal fold against it let a line above the summary retire a park
+ * the summary itself declares: `run-start · task-dispatch T1 · run-end
+ * human:[T1]` read `interrupted`, and the same journal with a `task-done T1`
+ * read `done` — OBS-252 again, one line lower.
+ *
+ * So a name is resolved only when a later event moved that task: approved,
+ * redispatched, finished, landed. Nothing later — including a task the record
+ * never mentions at all — leaves the park standing, because an uncorroborated
+ * park is still the run's own claim that it is waiting and withholding `done`
+ * on a claim the surface cannot check is the fail-closed reading. It stays a
+ * reading of the run and of the tasks it names: a summary is a journal event,
+ * so its explicit task outcomes are facts the board must count and draw even
+ * when the more detailed task event is absent.
+ */
+function unresolvedSummaryParks(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event.event !== "run-end")
+            continue;
+        const parked = Array.isArray(event.data.human) ? event.data.human : [];
+        const released = new Map();
+        for (const later of events.slice(index + 1)) {
+            if (later.taskId === undefined)
+                continue;
+            if (!TASK_STATE_BY_EVENT.has(later.event))
+                continue;
+            released.set(later.taskId, later.event !== "task-human");
+        }
+        return parked.filter((id) => typeof id === "string" && released.get(id) !== true);
+    }
+    return [];
+}
 function deriveTasks(events, interrupted) {
     const tasks = new Map();
     const task = (taskId, index, ts) => {
@@ -126,6 +195,8 @@ function deriveTasks(events, interrupted) {
             id: taskId,
             dispatches: [],
             state: undefined,
+            parkKind: undefined,
+            merged: false,
             lastIndex: index,
             lastTs: ts,
             phase: "pending",
@@ -134,6 +205,30 @@ function deriveTasks(events, interrupted) {
         return created;
     };
     for (const [index, event] of events.entries()) {
+        if (event.event === "run-end") {
+            // The closing summary is a recorded fold, not commentary. Apply all
+            // task outcomes it owns before later resume events get their ordinary
+            // chance to supersede them. Failure comes last so a malformed overlap
+            // fails closed instead of repainting a failed task done.
+            const summaries = [
+                [event.data.done, "done"],
+                [event.data.human, "human"],
+                [event.data.failed, "failed"],
+            ];
+            for (const [ids, state] of summaries) {
+                for (const taskId of summaryTaskIds(ids)) {
+                    const fact = task(taskId, index, event.ts);
+                    fact.state = state;
+                    // A summary does not invent a park kind; it preserves one only when
+                    // it confirms that the same park still stands.
+                    if (state !== "human")
+                        fact.parkKind = undefined;
+                    fact.lastIndex = index;
+                    fact.lastTs = event.ts;
+                }
+            }
+            continue;
+        }
         if (!event.taskId)
             continue;
         if (event.event === "task-dispatch") {
@@ -148,11 +243,25 @@ function deriveTasks(events, interrupted) {
                 assignment: assignmentFrom(event.data.assignment),
             });
             fact.state = "running";
+            fact.parkKind = undefined;
             fact.phase = "worker";
             fact.lastIndex = index;
             fact.lastTs = event.ts;
             continue;
         }
+        if (event.event === "merge") {
+            const fact = task(event.taskId, index, event.ts);
+            fact.merged = true;
+            // A merge is a landing, and it is a state the journal recorded: the task
+            // is done, and whatever park it was released from is retired by the merge
+            // itself rather than by whichever event happened to precede it. Nothing
+            // here depends on a `task-done` line arriving first (OBS-256).
+            fact.state = "done";
+            fact.parkKind = undefined;
+            fact.lastIndex = index;
+            fact.lastTs = event.ts;
+            continue;
+        }
         if (event.event === "phase-start") {
             const fact = task(event.taskId, index, event.ts);
             fact.phase = typeof event.data.phase === "string" ? event.data.phase : fact.phase;
@@ -160,15 +269,19 @@ function deriveTasks(events, interrupted) {
             fact.lastTs = event.ts;
             continue;
         }
-        const state = {
-            "task-done": "done",
-            "task-failed": "failed",
-            "task-human": "human",
-            "task-approved": "pending",
-        }[event.event];
+        // `task-dispatch` and `merge` returned above; the rest write their state and
+        // nothing else. One list, read from one place, so a new state-writing event
+        // cannot move the fold without also moving what resolves a park.
+        const state = TASK_STATE_BY_EVENT.get(event.event);
         if (state) {
             const fact = task(event.taskId, index, event.ts);
             fact.state = state;
+            // The park kind travels with the park: `task-human` records it, and the
+            // next recorded state — approved, done, failed — retires it with the park
+            // it named. A resolved state must not leave its badge behind (OBS-256).
+            fact.parkKind = state === "human" && typeof event.data.kind === "string"
+                ? event.data.kind
+                : undefined;
             fact.lastIndex = index;
             fact.lastTs = event.ts;
         }
@@ -250,14 +363,42 @@ function recordsFailure(event) {
         || event.data.pass === false
         || event.data.ok === false
         || (typeof event.data.exitCode === "number" && event.data.exitCode !== 0)
-        || (event.event === "run-end" && event.data.tipVerify === "failed");
+        || (event.event === "run-end"
+            && (event.data.tipVerify === "failed"
+                || summaryTaskIds(event.data.failed).length > 0));
 }
+/**
+ * The outcome an event records as a success. `merge` is here and `task-done` is
+ * not: a merge records the landing, and a completion records only that the
+ * worker stopped working — the gates that judge it and the merge that lands it
+ * come after. A `run-end` counts only when its tip verification reads passed:
+ * an absent verdict is nothing verified, and a check-mark on nothing verified
+ * is the run claiming a pass tickmarkr never corroborated — the same
+ * fail-closed reading the status strip already draws (OBS-244), now on the row.
+ */
 function recordsSuccess(event) {
-    return event.event === "task-done"
-        || event.event === "merge"
+    return event.event === "merge"
         || event.data.pass === true
         || event.data.ok === true
-        || (event.event === "run-end" && event.data.tipVerify !== "failed");
+        || (event.event === "run-end" && event.data.tipVerify === "passed");
+}
+/** The newest run-end speaks for the run; spotlight is context, not outcome. */
+function runPresentation(runStatus, spotlight) {
+    switch (runStatus) {
+        case "failed":
+            return { state: "fail", word: "failed" };
+        case "parked":
+            return { state: "warn", word: "parked" };
+        case "interrupted":
+            return { state: "warn", word: "interrupted" };
+        case "running":
+            return { state: "neutral", word: "running" };
+        case "done":
+            // A task named beside the run still earns a check only from its merge.
+            return spotlight === undefined || spotlight.merged
+                ? { state: "pass", word: "pass" }
+                : { state: "neutral", word: "done" };
+    }
 }
 /**
  * A row depicts the event it names: the event's own recorded outcome decides
@@ -268,11 +409,25 @@ function recordsSuccess(event) {
  * Every state carries its word, so meaning never rides on hue alone.
  */
 function eventPresentation(event, task) {
-    if (event.event === "escalation" || event.event === "task-human") {
+    if (event.event === "escalation")
         return { state: "warn", word: "warn" };
-    }
+    // A park is a state, not a severity: the row says what the engagement is
+    // waiting for, which is the operator.
+    if (event.event === "task-human")
+        return { state: "warn", word: "parked" };
     if (recordsFailure(event))
         return { state: "fail", word: "fail" };
+    if (event.event === "run-end"
+        && summaryTaskIds(event.data.human).length > 0) {
+        return { state: "warn", word: "parked" };
+    }
+    // Work finished is not work landed. `task-done` records the first, so its row
+    // says `done` and carries no check: the check-mark belongs to the `merge` that
+    // records the landing, and until the journal writes one there is nothing to
+    // put it on (OBS-256). This is the same reading `taskPresentation` gives the
+    // task itself, stated here for the event because a row depicts its own event.
+    if (event.event === "task-done")
+        return { state: "neutral", word: "done" };
     if (recordsSuccess(event))
         return { state: "pass", word: "pass" };
     if (task?.state === "interrupted") {
@@ -282,19 +437,29 @@ function eventPresentation(event, task) {
 }
 function historyRow(event, tasks, spotlight, newest, runStatus) {
     const task = event.taskId === undefined ? undefined : tasks.get(event.taskId);
-    const { state, word } = eventPresentation(event, task);
+    // Spotlight is context only for the taskless closing summary. A task-owned
+    // newest event keeps its own identity and outcome: T2's dispatch or failure
+    // cannot become a pass for merged T1 merely because T1 wins the spotlight.
+    const summary = newest && event.event === "run-end"
+        ? runPresentation(runStatus, spotlight)
+        : undefined;
+    const { state, word } = summary ?? eventPresentation(event, task);
+    const displayedTask = newest
+        ? event.taskId === undefined ? spotlight : task
+        : task;
     // The spotlight entry must keep the task, its attempt and its acting adapter
     // inside the narrowest band's width budget — that budget cannot pay for the
     // separators and the event name, so the state word and the run's status
     // (what the newest event recorded) ride after the adapter instead.
-    const text = newest && spotlight !== undefined
-        ? `${spotlight.id} attempt ${taskAttempt(spotlight)} ${taskActor(spotlight)} ${word}${word === runStatus ? "" : ` ${runStatus}`}`
+    const text = newest && displayedTask !== undefined
+        ? `${displayedTask.id} attempt ${taskAttempt(displayedTask)} ${taskActor(displayedTask)} ${word}${word === runStatus ? "" : ` ${runStatus}`}`
         : task !== undefined
             ? `${task.id} ${word} · ${event.event}`
             : `${word} · ${event.event}`;
     return {
         id: `event:${event.line}`,
         time: eventTime(event.ts),
+        timestamp: event.ts,
         state,
         text,
     };
@@ -332,14 +497,28 @@ 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;
         return {
             id: `task:${id}`,
             taskId: id,
-            ...(fact?.state === undefined ? {} : { state: fact.state }),
+            ...(state === undefined ? {} : { state }),
             ...(attempts === 0 ? {} : { attempts }),
             ...(assignment === undefined ? {} : { actor: channelKey(assignment) }),
             ...(lastTs === undefined ? {} : { lastEventTime: eventTime(lastTs) }),
+            ...(lastTs === undefined ? {} : { lastEventTimestamp: lastTs }),
             ...(title === undefined ? {} : { title }),
+            // Only while the park stands: the fold cleared it the moment the journal
+            // recorded what the park resolved to.
+            ...(fact?.parkKind === undefined ? {} : { parkKind: fact.parkKind }),
+            // 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 } : {}),
         };
     });
 }
@@ -356,6 +535,7 @@ function gateRows(events) {
         return [{
                 id: `gate:${event.line}`,
                 time: eventTime(event.ts),
+                timestamp: event.ts,
                 state: pass === true ? "pass" : pass === false ? "fail" : "neutral",
                 ...(typeof event.data.gate === "string" ? { gate: event.data.gate } : {}),
                 ...(event.taskId === undefined ? {} : { taskId: event.taskId }),
@@ -421,6 +601,7 @@ function fleetRows(events) {
         model: channel.model,
         ...(channel.dispatches === 0 ? {} : { dispatches: channel.dispatches }),
         lastEventTime: eventTime(channel.lastTs),
+        lastEventTimestamp: channel.lastTs,
     }));
 }
 /**
@@ -535,15 +716,30 @@ export function deriveRunCockpitData(source, binaryVersion, options = {}) {
     const tipPassed = tipVerificationPassed(events);
     const spotlight = spotlightTask(tasks);
     const samples = bucketedMetricSamples(events);
+    // A task the journal carried somewhere other than done — approved and awaiting
+    // the resume that redispatches it, most of all. `done` is a claim about all of
+    // them, so one outstanding task retires it.
+    const outstanding = taskFacts.some((task) => task.state !== undefined && task.state !== "done");
+    // Parked outranks every reading but failure: a run holding an unresolved
+    // `human` task owes the operator a verb, and the daemon's exit after a park is
+    // the park's own consequence — not an interruption, and never done. A run that
+    // also failed a task owes a fix first, so failure still leads (OBS-252).
+    //
+    // The word is owed on two readings, not one: the parks the fold holds, and
+    // the parks the latest run-end names and nothing since resolved. The second
+    // is what keeps the reading off the luck of a `task-human` line preceding the
+    // run-end — the run's own closing statement is enough.
     const runStatus = failed > 0
         ? "failed"
-        : lifecycle === "superseded" || hasInterruptedTask
-            ? "interrupted"
-            : lifecycle === "completed"
-                ? "done"
-                : interrupted
-                    ? "interrupted"
-                    : "running";
+        : human > 0 || unresolvedSummaryParks(events).length > 0
+            ? "parked"
+            : lifecycle === "superseded" || hasInterruptedTask
+                ? "interrupted"
+                : lifecycle === "completed"
+                    ? outstanding ? "interrupted" : "done"
+                    : interrupted
+                        ? "interrupted"
+                        : "running";
     return {
         binaryVersion,
         runId: source.fileName.replace(/(?:\.interrupted)?\.journal\.jsonl$/, ""),

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

@@ -53,33 +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;
+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, }) {
@@ -117,7 +195,7 @@ 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
@@ -189,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}`}`,
         }));
@@ -211,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";
 }
@@ -270,7 +364,10 @@ function SizedJournalPanel({ rows, bodyRows, title, selection, focused, }) {
         : 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,
@@ -294,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
@@ -419,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) {
@@ -450,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)
@@ -511,12 +609,12 @@ function LadderRunPanel({ data, content, compactMeterWidth, interaction, keyEntr
         return (_jsx(SizedLinesPanel, { title: "HELP", lines: helpLines(keyEntries), bodyRows: content.items.rows, wrapColumns: content.items.columns, focused: focused, flexGrow: 1 }));
     }
     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 })
-                    : (_jsx(CompactProgress, { data: data, caption: content.progressCaption, meterWidth: compactMeterWidth }))), content.journal > 0 && (_jsx(JournalBody, { data: data, interaction: interaction, bodyRows: content.journal, keyEntries: keyEntries }))] }) }));
+                    ? (_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
@@ -528,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),
     ];
@@ -588,7 +689,7 @@ function RunCockpitPaint({ data, columns, plan, content, interaction, keyProject
                             : (_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: content.sideRails ? undefined : 24, interaction: currentInteraction, keyEntries: keyEntries, focused: contentFocused }))
+                                    ? (_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. */