tickmarkr 1.80.0 → 1.83.0

package/dist/tui/cockpit/components.js

@@ -1,46 +1,31 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { Box, Text } from "ink";
 import { Children } from "react";
-import stringWidth from "string-width";
 import { GLYPHS } from "../../brand.js";
 import { COCKPIT_DATA_RAMP, COCKPIT_INKS, TEXT_EMPHASIS_TOKENS, } from "./theme.js";
 import { SPARKLINE_BUCKET_WINDOW } from "./derive.js";
 export { SPARKLINE_BUCKET_WINDOW } from "./derive.js";
+import { formatKeybarEntries, keybarEntries, SETUP_KEY_BINDINGS, } from "./keys.js";
+/**
+ * Measurement and cutting come from the cockpit's one width authority; this
+ * file owns no width table and counts no code points of its own. The local
+ * name stays `stringWidth` because `keys.test.ts`'s branch ledger proves the
+ * roster's fit branch by naming that line of this file verbatim and watching
+ * the named test fail without it — renaming the call would leave the ledger
+ * reporting a missing anchor instead of a covered branch. The name is the
+ * ledger's; the measurement is `cellWidth`, and `string-width` the package is
+ * no longer imported here.
+ */
+import { cellWidth as stringWidth, sliceCells } from "./width.js";
 const SPARKLINE_GLYPHS = ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
 const BAND_GAP_COLUMNS = 1;
 const PANEL_HORIZONTAL_CHROME = 4;
 const READABLE_PANEL_COLUMNS = 20;
 export const PANEL_CHROME_ROWS = 3;
 export const BAND_CONTINUATION_PREFIX = "↳ ";
-const RUN_KEYS = [
-    { key: "↑↓", label: "Move" },
-    { key: "⏎", label: "Open" },
-    { key: "←", label: "Back" },
-    { key: "Tab", label: "Panel" },
-    { key: "?", label: "Help" },
-    { key: "q", label: "Quit" },
-    { key: "f", label: "Follow" },
-    { key: "/", label: "Filter" },
-];
-const SETUP_ADDITIONAL_KEYS = [
-    { key: "␣", label: "Toggle" },
-    { key: "a", label: "All" },
-    { key: "r", label: "Re-probe" },
-    { key: "s", label: "Save" },
-    { key: "n", label: "Next" },
-    { key: "p", label: "Prev" },
-];
-const SETUP_KEYS = [
-    RUN_KEYS[0],
-    { key: RUN_KEYS[1].key, label: "Next" },
-    RUN_KEYS[2],
-    RUN_KEYS[3],
-    RUN_KEYS[4],
-    RUN_KEYS[5],
-    ...SETUP_ADDITIONAL_KEYS,
-];
+const SETUP_KEYS = keybarEntries(SETUP_KEY_BINDINGS);
+const SETUP_ADDITIONAL_KEYS = SETUP_KEYS.slice(6);
 export const KEYBAR_KEYS = {
-    run: RUN_KEYS,
     setup: SETUP_KEYS,
     setupAdditional: SETUP_ADDITIONAL_KEYS,
 };
@@ -108,27 +93,6 @@ export function allocateBandColumns(columns, content, options = {}) {
     const shares = apportion(usable - base.reduce((sum, value) => sum + value, 0), preferred.map((value, index) => value - base[index]));
     return base.map((value, index) => value + shares[index]);
 }
-function takeDisplayColumns(value, columns) {
-    const characters = [...value];
-    let used = 0;
-    let taken = 0;
-    while (taken < characters.length) {
-        const width = stringWidth(characters[taken]);
-        if (taken > 0 && used + width > columns)
-            break;
-        if (taken === 0 && width > columns) {
-            taken = 1;
-            break;
-        }
-        used += width;
-        taken += 1;
-    }
-    const concatenate = (items) => items.reduce((result, character) => result + character, "");
-    return [
-        concatenate(characters.slice(0, taken)),
-        concatenate(characters.slice(taken)),
-    ];
-}
 /**
  * Compose one data line into visible rows. A fitting line is byte-for-byte
  * untouched. Every wrapped row carries a continuation marker before any
@@ -164,7 +128,7 @@ export function composeBandLine(text, columns) {
                 continue;
             }
             const available = Math.max(1, width - stringWidth(current));
-            const [head, tail] = takeDisplayColumns(word, available);
+            const { head, tail } = sliceCells(word, available);
             current += head;
             word = tail;
             if (word.length === 0)
@@ -269,12 +233,42 @@ export function ProgressMeter({ value, width = 24, }) {
 function OneLineItems({ children, width, label, }) {
     return (_jsx(Box, { flexDirection: "row", flexWrap: "nowrap", width: width, height: 1, overflow: "hidden", "aria-label": label, children: children }));
 }
-export function Keybar({ surface, width, }) {
-    return (_jsx(OneLineItems, { width: width, label: `${surface} cockpit keys`, children: KEYBAR_KEYS[surface].map((item, index) => (_jsxs(Box, { flexShrink: 0, children: [index > 0 && _jsx(BodyText, { emphasis: "dim", children: " \u00B7 " }), _jsx(BodyText, { emphasis: "strong", children: item.key }), _jsxs(BodyText, { emphasis: "dim", children: [" ", item.label] })] }, item.key))) }));
+/**
+ * Wrap a projected roster without losing a byte. Unlike prose wrapping, these
+ * rows are exact consecutive slices: stripping continuation markers and
+ * joining the slices reconstructs the registry projection byte for byte.
+ */
+export function keyRosterLines(entries, columns) {
+    const width = Math.max(1, Math.floor(columns));
+    const formatted = formatKeybarEntries(entries);
+    if (stringWidth(formatted) <= width)
+        return [formatted];
+    const rendered = [];
+    let remaining = formatted;
+    let first = true;
+    while (remaining.length > 0) {
+        const prefix = first ? "" : BAND_CONTINUATION_PREFIX;
+        const available = Math.max(1, width - stringWidth(prefix));
+        const { head: slice, tail } = sliceCells(remaining, available);
+        // Ink trims terminal-row trailing spaces. Carry them to the next slice so
+        // the painted representation still reconstructs the formatted roster.
+        const trailingSpace = slice.match(/\s+$/u)?.[0] ?? "";
+        const head = trailingSpace.length === 0
+            ? slice
+            : slice.slice(0, -trailingSpace.length);
+        rendered.push(`${prefix}${head}`);
+        remaining = trailingSpace + tail;
+        first = false;
+    }
+    return rendered;
+}
+/** The lossless, width-safe rendering of one projected key roster. */
+export function KeyRoster({ entries, width, }) {
+    return (_jsx(Box, { flexDirection: "column", width: width, "aria-label": "run cockpit keys", children: keyRosterLines(entries, width).map((line, index) => (_jsx(BodyText, { emphasis: "dim", children: line }, `${index}:${line}`))) }));
 }
 export function StatusStrip({ items, width, }) {
     return (_jsx(OneLineItems, { width: width, label: "cockpit status", children: items.map((item, index) => (_jsxs(Box, { flexShrink: 0, children: [index > 0 && _jsx(BodyText, { emphasis: "dim", children: " \u00B7 " }), _jsx(StateGlyph, { state: item.state }), _jsxs(BodyText, { children: [" ", item.text] })] }, `${item.state}:${item.text}`))) }));
 }
-export function JournalRowPanel({ rows, width, focused, title = "JOURNAL", }) {
-    return (_jsx(Panel, { title: title, focused: focused, width: width, children: rows.map((row, index) => (_jsxs(Box, { flexDirection: "row", flexWrap: "nowrap", height: 1, overflow: "hidden", children: [_jsx(BodyText, { emphasis: "dim", children: row.time }), _jsx(BodyText, { children: " " }), _jsx(StateGlyph, { state: row.state }), _jsxs(BodyText, { children: [" ", row.text] })] }, row.id ?? `${row.time}:${row.state}:${index}`))) }));
+export function JournalRowPanel({ rows, width, focused, title = "JOURNAL", selection, }) {
+    return (_jsx(Panel, { title: title, focused: focused, width: width, children: rows.map((row, index) => (_jsxs(Box, { flexDirection: "row", flexWrap: "nowrap", height: 1, overflow: "hidden", children: [_jsx(BodyText, { emphasis: "dim", children: row.time }), _jsx(BodyText, { children: " " }), _jsx(StateGlyph, { state: row.state }), _jsx(BodyText, { children: " " }), index === selection && (_jsxs(BodyText, { emphasis: "strong", children: [GLYPHS.pointer, " "] })), _jsx(BodyText, { children: row.text })] }, row.id))) }));
 }

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

@@ -1,4 +1,5 @@
-import type { JournalRow, StatusStripItem } from "./components.js";
+import type { ComponentState, JournalRow, StatusStripItem } from "./components.js";
+import type { RunViewId } from "./views.js";
 export declare const SPARKLINE_BUCKET_WINDOW = 12;
 export declare function selectSparklineBucketWidthMs(elapsedMs: number): number;
 type MetricSample = number | null;
@@ -26,6 +27,9 @@ export type RunCockpitData = {
     readonly progress: number;
     readonly progressCaption: string;
     readonly journalRows: readonly JournalRow[];
+    readonly taskRows: readonly TaskRow[];
+    readonly gateRows: readonly GateRow[];
+    readonly fleetRows: readonly FleetRow[];
     readonly statusItems: readonly StatusStripItem[];
 };
 export type RunCockpitSource = {
@@ -34,6 +38,74 @@ export type RunCockpitSource = {
 };
 export type RunCockpitDeriveOptions = {
     readonly isDaemonAlive?: (pid: number) => boolean;
+    /** The compiled graph, when the engagement has one. Identity only — see CockpitGraph. */
+    readonly graph?: CockpitGraph;
 };
+/**
+ * What the compiled graph lends the cockpit: which tasks exist, in what order,
+ * and what each is called. `status` is named here only to state that it is
+ * deliberately unread — the journal owns state, so a recompile can never
+ * repaint a parked task green.
+ */
+export type CockpitGraph = {
+    readonly tasks: readonly {
+        readonly id: string;
+        readonly title?: string;
+        readonly status?: string;
+    }[];
+};
+/** How an unrecorded field draws: the engagement said nothing, so the row says nothing. */
+export declare const ABSENT_FIELD = "-";
+/**
+ * One reading of a row field. An absent field is a fact about the engagement —
+ * it never recorded this — and never collapses into an empty string or a zero
+ * that reads like a measurement.
+ */
+export declare function fieldReading(value: string | number | undefined): string;
+/**
+ * One task of the compiled graph, wearing only what the journal recorded about
+ * it. A task the journal never mentions still draws a row; its state, attempts,
+ * actor and last event time are absent rather than invented — including the
+ * state, because "pending" is a thing the engagement would have to have
+ * recorded, not a thing a row may assume about silence.
+ *
+ * `attempts` is a count of recorded dispatches, never the newest dispatch's
+ * `attempt` label: labels restart at zero on resume, so the label of the last
+ * dispatch understates a task the engagement resumed into.
+ */
+export type TaskRow = {
+    readonly id: string;
+    readonly taskId: string;
+    readonly state?: TaskState;
+    readonly attempts?: number;
+    readonly actor?: string;
+    readonly lastEventTime?: string;
+    readonly title?: string;
+};
+/** One recorded gate result. `details` is the record's own text, verbatim. */
+export type GateRow = {
+    readonly id: string;
+    readonly time: string;
+    readonly state: ComponentState;
+    readonly gate?: string;
+    readonly taskId?: string;
+    readonly pass?: boolean;
+    readonly details?: string;
+};
+/** One channel the engagement recorded, dispatched to or merely named. */
+export type FleetRow = {
+    readonly id: string;
+    readonly adapter: string;
+    readonly model: string;
+    readonly dispatches?: number;
+    readonly lastEventTime?: string;
+};
+export type TaskState = "done" | "failed" | "human" | "pending" | "running" | "interrupted";
+/**
+ * The source identities the named view's rows carry, in draw order. Selection
+ * is repaired against these, so it follows a row across a refresh instead of
+ * following the index the row happened to occupy.
+ */
+export declare function runViewRowIdentities(data: RunCockpitData, viewId: RunViewId, filterQuery?: string): readonly string[];
 export declare function deriveRunCockpitData(source: RunCockpitSource, binaryVersion: string, options?: RunCockpitDeriveOptions): RunCockpitData;
 export {};

package/dist/tui/cockpit/derive.js

@@ -1,3 +1,4 @@
+import { channelKey } from "../../adapters/types.js";
 export const SPARKLINE_BUCKET_WINDOW = 12;
 const MINUTE_MS = 60_000;
 const SPARKLINE_BUCKET_WIDTH_LADDER_MINUTES = [
@@ -22,6 +23,16 @@ export function selectSparklineBucketWidthMs(elapsedMs) {
         coarsened *= 2;
     return coarsened * MINUTE_MS;
 }
+/** How an unrecorded field draws: the engagement said nothing, so the row says nothing. */
+export const ABSENT_FIELD = "-";
+/**
+ * One reading of a row field. An absent field is a fact about the engagement —
+ * it never recorded this — and never collapses into an empty string or a zero
+ * that reads like a measurement.
+ */
+export function fieldReading(value) {
+    return value === undefined ? ABSENT_FIELD : String(value);
+}
 function recordValue(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value)
         ? value
@@ -114,7 +125,7 @@ function deriveTasks(events, interrupted) {
         const created = {
             id: taskId,
             dispatches: [],
-            state: "pending",
+            state: undefined,
             lastIndex: index,
             lastTs: ts,
             phase: "pending",
@@ -164,13 +175,36 @@ function deriveTasks(events, interrupted) {
     }
     if (interrupted) {
         for (const fact of tasks.values()) {
-            if (fact.state === "running" || fact.state === "pending") {
+            // Only a task the journal recorded as running. `task-dispatch` recorded
+            // that it started; no event records how it ended; the daemon that would
+            // have recorded that ending is gone. So the recorded state cannot still
+            // be true, and its interruption is a reading of that record — not an
+            // invention on top of silence.
+            //
+            // Silence stays silent. A task the engagement mentioned without ever
+            // recording a state keeps none: the run's stopping is a fact about the
+            // run, and lending it to a task would be exactly the assumption an absent
+            // field exists to refuse.
+            //
+            // A state the journal did record otherwise is never overwritten —
+            // `pending` is what `task-approved` recorded, and it says the task was
+            // released back to the pool to await a dispatch, not that a dispatch was
+            // cut short. In the real post-run approval sequence (run-end, then the
+            // operator approves) that approval is the newest thing the engagement
+            // recorded about the task, so reporting it as interrupted would be the
+            // run's stopping overruling the journal. The journal wins.
+            if (fact.state === "running")
                 fact.state = "interrupted";
-            }
         }
     }
     return tasks;
 }
+/**
+ * The label the engagement gave the attempt now standing — which is what the
+ * spotlight caption is naming ("attempt 3 of 4", the ladder's own numbering).
+ * Not a count of attempts: labels restart at zero on resume. Rows that mean
+ * "how many times was this tried" count dispatches instead — see TaskRow.
+ */
 function taskAttempt(fact) {
     return fact.dispatches.at(-1)?.attempt ?? Math.max(1, fact.dispatches.length);
 }
@@ -227,9 +261,10 @@ function recordsSuccess(event) {
 }
 /**
  * A row depicts the event it names: the event's own recorded outcome decides
- * the state, never the state its task reached later. Only a task with no
- * terminal event in a run whose daemon is gone lends its interruption, because
- * no event records that ending — the interruption is the run's present truth.
+ * the state, never the state its task reached later. Only a task the journal
+ * recorded as running, in a run whose daemon is gone, lends its interruption:
+ * a dispatch was recorded, no event records how it ended, and the process that
+ * would have recorded that ending is no longer there.
  * Every state carries its word, so meaning never rides on hue alone.
  */
 function eventPresentation(event, task) {
@@ -269,6 +304,147 @@ function journalRows(events, tasks, defects, runStatus) {
     const history = [...events].reverse().map((event, index) => historyRow(event, tasks, spotlight, index === 0, runStatus));
     return [...[...defects].reverse().map(defectRow), ...history];
 }
+/**
+ * The tasks the engagement owns, in the compiled graph's order: the graph
+ * supplies identity and nothing else, so a task the journal never mentions
+ * still draws a row. Every other field is read off recorded events — the
+ * 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 lastSeen = new Map();
+    for (const event of events) {
+        if (event.taskId !== undefined)
+            lastSeen.set(event.taskId, event.ts);
+    }
+    const identities = graph !== undefined
+        ? graph.tasks.map((task) => ({ id: task.id, title: task.title }))
+        // Without a graph the engagement's own records are the only identities there are.
+        : [...new Set([...tasks.keys(), ...lastSeen.keys()])].map((id) => ({
+            id,
+            title: undefined,
+        }));
+    return identities.map(({ id, title }) => {
+        const fact = tasks.get(id);
+        const assignment = fact?.dispatches.at(-1)?.assignment;
+        const lastTs = lastSeen.get(id);
+        // Counted, not read off the newest dispatch's label: the label restarts at
+        // 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;
+        return {
+            id: `task:${id}`,
+            taskId: id,
+            ...(fact?.state === undefined ? {} : { state: fact.state }),
+            ...(attempts === 0 ? {} : { attempts }),
+            ...(assignment === undefined ? {} : { actor: channelKey(assignment) }),
+            ...(lastTs === undefined ? {} : { lastEventTime: eventTime(lastTs) }),
+            ...(title === undefined ? {} : { title }),
+        };
+    });
+}
+/**
+ * One row per recorded gate result, newest first. The recorded details ride
+ * through untouched — the operator reads the reviewer's findings and the
+ * failing test names as the gate wrote them, never a rephrasing.
+ */
+function gateRows(events) {
+    const rows = events.flatMap((event) => {
+        if (event.event !== "gate-result")
+            return [];
+        const pass = typeof event.data.pass === "boolean" ? event.data.pass : undefined;
+        return [{
+                id: `gate:${event.line}`,
+                time: eventTime(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 }),
+                ...(pass === undefined ? {} : { pass }),
+                ...(typeof event.data.details === "string" ? { details: event.data.details } : {}),
+            }];
+    });
+    return rows.reverse();
+}
+/** An `adapter:model` channel key back into its parts, or nothing if it is not one. */
+function splitChannelKey(key) {
+    const separator = key.indexOf(":");
+    if (separator <= 0 || separator >= key.length - 1)
+        return undefined;
+    return { adapter: key.slice(0, separator), model: key.slice(separator + 1) };
+}
+/**
+ * One row per channel the engagement recorded, in the order it first named
+ * them — starting with the roster it recorded at run-start, which is the whole
+ * fleet it could have dispatched to, then any channel a later event named that
+ * the roster did not. A channel it named without dispatching — a roster seat it
+ * never used, or the static choice a failover passed over — carries no dispatch
+ * count at all, because zero dispatches is something the engagement never
+ * measured, not a measurement of zero.
+ */
+function fleetRows(events) {
+    const channels = new Map();
+    const note = (channel, ts, dispatched) => {
+        const key = channelKey(channel);
+        const existing = channels.get(key)
+            ?? { adapter: channel.adapter, model: channel.model, dispatches: 0, lastTs: ts };
+        channels.set(key, {
+            ...existing,
+            dispatches: existing.dispatches + (dispatched ? 1 : 0),
+            lastTs: ts,
+        });
+    };
+    const noteKeys = (recorded, ts) => {
+        for (const key of recorded) {
+            const channel = typeof key === "string" ? splitChannelKey(key) : undefined;
+            if (channel)
+                note(channel, ts, false);
+        }
+    };
+    for (const event of events) {
+        if (event.event === "run-start" && Array.isArray(event.data.channels)) {
+            noteKeys(event.data.channels, event.ts);
+            continue;
+        }
+        if (event.event === "task-dispatch") {
+            const assignment = assignmentFrom(event.data.assignment);
+            if (assignment)
+                note(assignment, event.ts, true);
+            continue;
+        }
+        if (event.event === "failover-deviation") {
+            noteKeys([event.data.static, event.data.chosen], event.ts);
+        }
+    }
+    return [...channels.entries()].map(([key, channel]) => ({
+        id: `channel:${key}`,
+        adapter: channel.adapter,
+        model: channel.model,
+        ...(channel.dispatches === 0 ? {} : { dispatches: channel.dispatches }),
+        lastEventTime: eventTime(channel.lastTs),
+    }));
+}
+/**
+ * The source identities the named view's rows carry, in draw order. Selection
+ * is repaired against these, so it follows a row across a refresh instead of
+ * following the index the row happened to occupy.
+ */
+export function runViewRowIdentities(data, viewId, 
+// ponytail: the filter is the journal's, as it has always been; the promoted
+// views gain one when a criterion asks for it.
+filterQuery = "") {
+    if (viewId === "tasks")
+        return data.taskRows.map((row) => row.id);
+    if (viewId === "gates")
+        return data.gateRows.map((row) => row.id);
+    if (viewId === "fleet")
+        return data.fleetRows.map((row) => row.id);
+    if (viewId !== "journal")
+        return [];
+    const query = filterQuery.trim().toLowerCase();
+    return data.journalRows
+        .filter((row) => query === "" || row.text.toLowerCase().includes(query))
+        .map((row) => row.id);
+}
 function bucketedMetricSamples(events) {
     const taskSamples = Array.from({ length: SPARKLINE_BUCKET_WINDOW }, () => null);
     const gateTotals = Array.from({ length: SPARKLINE_BUCKET_WINDOW }, () => 0);
@@ -302,21 +478,35 @@ function bucketedMetricSamples(events) {
         passRate: gateTotals.map((total, index) => total === 0 ? null : Math.round((gatePasses[index] / total) * 100)),
     };
 }
+// OBS-244: the strip reports the LATEST verification cycle, never the whole journal conjoined.
+// The daemon runs the integration-tip commands and appends `run-end` in one breath (daemon.ts
+// finishRun), so a cycle is the tip-verify events recorded since the previous run-end together
+// with the verdict on the run-end that closes them — a mid-run failure a later cycle recovered is
+// no longer permanent red. `undefined` means nothing was verified: drawn absent, never passed.
+// Fail-closed everywhere else — a cycle with no closing verdict, or a verdict with no events, is
+// a failure, because a claim tickmarkr cannot corroborate is not a pass.
 function tipVerificationPassed(events) {
-    const eventVerdicts = events.flatMap((event) => {
+    const runEnds = events.flatMap((event, index) => event.event === "run-end" ? [index] : []);
+    const lastRunEnd = runEnds.at(-1);
+    const cycle = events.slice((runEnds.at(-2) ?? -1) + 1, lastRunEnd === undefined ? events.length : lastRunEnd + 1);
+    const cycleVerdicts = cycle.flatMap((event) => {
         if (event.event === "tip-verify-failed")
             return [false];
         if (event.event === "tip-verify")
             return [event.data.pass === true];
         return [];
     });
-    const endVerdicts = events.flatMap((event) => event.event === "run-end" && typeof event.data.tipVerify === "string"
-        ? [event.data.tipVerify === "passed"]
-        : []);
-    return eventVerdicts.length > 0
-        && endVerdicts.length > 0
-        && eventVerdicts.every(Boolean)
-        && endVerdicts.every(Boolean);
+    const closing = lastRunEnd === undefined
+        ? undefined
+        : events[lastRunEnd].data.tipVerify;
+    const endVerdict = typeof closing === "string"
+        ? closing === "passed"
+        : undefined;
+    if (cycleVerdicts.length === 0 && endVerdict === undefined)
+        return undefined;
+    return endVerdict === true
+        && cycleVerdicts.length > 0
+        && cycleVerdicts.every(Boolean);
 }
 export function deriveRunCockpitData(source, binaryVersion, options = {}) {
     const { events, defects } = parseSource(source.raw);
@@ -379,8 +569,14 @@ 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),
+        gateRows: gateRows(events),
+        fleetRows: fleetRows(events),
         statusItems: [
-            { state: tipPassed ? "pass" : "fail", text: `tip-verify ${tipPassed ? "passed" : "FAILED"}` },
+            {
+                state: tipPassed === undefined ? "neutral" : tipPassed ? "pass" : "fail",
+                text: `tip-verify ${tipPassed === undefined ? ABSENT_FIELD : tipPassed ? "passed" : "FAILED"}`,
+            },
             { state: "pass", text: `done ${done}` },
             { state: failed > 0 ? "fail" : "neutral", text: `failed ${failed}` },
             { state: human > 0 ? "warn" : "neutral", text: `human ${human}` },