tickmarkr 2.4.2 → 2.5.0

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

@@ -0,0 +1,210 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+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 { buildOperatorRecord, formatOperatorRecordRow } from "../../report/operator-record.js";
+import { formatJournalNarration } from "../../run/journal.js";
+import { BodyText, JournalRowPanel, Panel } from "./components.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;
+/** Durable artifact locations named inside a gate/review's recorded detail text. */
+export function parseArtifactLocations(details) {
+    return [...details.matchAll(ARTIFACT_PATTERN)].map((m) => m[1]);
+}
+function stateFor(e) {
+    if (e.event === "gate-result" || e.event === "review-leg2")
+        return e.data.pass === true ? "pass" : e.data.pass === false ? "fail" : "neutral";
+    if (e.event === "task-failed")
+        return "fail";
+    if (e.event === "task-human" || e.event === "task-blocked")
+        return "warn";
+    if (e.event === "merge" || e.event === "task-done" || e.event === "run-end")
+        return "pass";
+    if (e.event === "task-dispatch" || e.event === "run-start" || e.event === "run-resume")
+        return "active";
+    return "neutral";
+}
+/** Pure C2-journal-to-Evidence-rows mapping: the original journal position IS the evidence identity
+ *  — assigned once here, from the full unfiltered event list, never recomputed from a display slice. */
+export function deriveEvidenceJournal(eventsOrRows, source = "journal.jsonl") {
+    const result = [];
+    for (let i = 0; i < eventsOrRows.length; i++) {
+        const item = eventsOrRows[i];
+        let e;
+        let line;
+        let rowSource = source;
+        let id;
+        if ("line" in item && typeof item.line === "number") {
+            if (!item.event)
+                continue;
+            e = item.event;
+            line = item.line;
+            rowSource = item.source ?? source;
+            id = item.id ?? `${rowSource}#L${line}`;
+        }
+        else {
+            e = item;
+            line = i + 1;
+            id = `${source}#L${line}`;
+        }
+        if (!e)
+            continue;
+        const details = typeof e.data?.details === "string" ? e.data.details : "";
+        const artifacts = parseArtifactLocations(details);
+        if (typeof e.data?.artifactPath === "string" && e.data.artifactPath.trim()) {
+            const p = e.data.artifactPath.trim();
+            if (!artifacts.includes(p))
+                artifacts.push(p);
+        }
+        const gate = typeof e.data?.gate === "string" ? e.data.gate : (e.event === "review-leg2" ? "review" : undefined);
+        result.push({
+            evidence: { source: rowSource, line, id },
+            time: e.ts,
+            state: stateFor(e),
+            text: formatJournalNarration(e),
+            fullText: details,
+            artifacts,
+            ...(e.taskId ? { taskId: e.taskId } : {}),
+            ...(gate ? { gate } : {}),
+        });
+    }
+    return result;
+}
+/** The most recent review verdict recorded for a task — by original journal position, so a merged
+ *  task's review opens the row it actually happened on rather than any on-screen index. */
+export function selectTaskReview(journal, taskId) {
+    for (let i = journal.length - 1; i >= 0; i--) {
+        const row = journal[i];
+        if (row.taskId === taskId && (row.gate === "review" || row.gate === "review-leg2"))
+            return row;
+    }
+    return undefined;
+}
+export function deriveEvidenceView(input) {
+    const source = input.source ?? "journal.jsonl";
+    const items = input.rows ?? input.events ?? [];
+    const events = input.rows
+        ? input.rows.flatMap((r) => (r.event ? [r.event] : []))
+        : (input.events ?? []);
+    return {
+        journal: deriveEvidenceJournal(items, source),
+        channels: buildOperatorRecord(events, input.costs ?? []),
+        reportLines: input.reportLines ?? [],
+        statsLines: input.statsLines ?? [],
+        learningPreview: input.learningPreview?.length ? input.learningPreview : ["no telemetry yet"],
+    };
+}
+/** The default beside-spec destination, or undefined when the source spec is ambiguous or unknown —
+ *  an ambiguous/missing source never guesses a path; the caller must ask for explicit choice. */
+export function defaultExportPath(target) {
+    if (target.specPaths.length !== 1 || !target.specDir)
+        return undefined;
+    const specPath = target.specPaths[0];
+    const base = specPath.split("/").pop() ?? specPath;
+    const stem = base.includes(".") ? base.slice(0, base.lastIndexOf(".")) : base;
+    return `${target.specDir}/${stem}.${target.runId}.report.md`;
+}
+export function planEvidenceExport(path, io) {
+    return { path, exists: io.existsSync(path) };
+}
+export function writeEvidenceExport(path, record, io, confirmedOverwrite = false) {
+    if (io.existsSync(path) && !confirmedOverwrite) {
+        return { ok: false, reason: "exists — overwrite not confirmed" };
+    }
+    const dir = dirname(path);
+    const base = basename(path);
+    const tempPath = join(dir, `.${base}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`);
+    try {
+        io.writeFileSync(tempPath, record, { flag: "wx" });
+        if (io.existsSync(path) && !confirmedOverwrite) {
+            try {
+                (io.unlinkSync ?? unlinkSync)(tempPath);
+            }
+            catch { }
+            return { ok: false, reason: "exists — overwrite not confirmed" };
+        }
+        (io.renameSync ?? renameSync)(tempPath, path);
+    }
+    catch (error) {
+        const isEexist = (typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST")
+            || (error instanceof Error && error.message.includes("EEXIST"));
+        if (!isEexist) {
+            try {
+                (io.unlinkSync ?? unlinkSync)(tempPath);
+            }
+            catch { }
+        }
+        return { ok: false, reason: error instanceof Error ? error.message : String(error) };
+    }
+    const bytes = (io.statSync ? io.statSync(path).size : undefined) ?? (existsSync(path) ? statSync(path).size : Buffer.byteLength(record, "utf8"));
+    return { ok: true, path, bytes };
+}
+// ── View ─────────────────────────────────────────────────────────────────────────────────────────
+const TABS = ["journal", "report", "stats", "channels", "learning"];
+const TAB_TITLE = {
+    journal: "JOURNAL", report: "REPORT", stats: "STATS", channels: "CHANNELS", learning: "LEARNING PREVIEW",
+};
+/** The exported Evidence body: C1 mounts this against a live EvidenceViewModel. Selection is held by
+ *  original journal line in local state — never recomputed from the array's current length — so a
+ *  newly appended row can never steal it while Follow is off; toggling Follow on snaps back to the
+ *  tail. */
+export function EvidenceView({ model, width, focused = true, focusEvidence, onSelect, onExport }) {
+    const [tab, setTab] = useState("journal");
+    const [follow, setFollow] = useState(focusEvidence === undefined);
+    const [selectedLine, setSelectedLine] = useState(focusEvidence?.line ?? model.journal.at(-1)?.evidence.line);
+    // model.journal.length (not the array itself) drives re-selection on growth; `follow` drives the
+    // snap-back-to-tail transition when the operator turns it on.
+    useEffect(() => {
+        if (follow)
+            setSelectedLine(model.journal.at(-1)?.evidence.line);
+    }, [model.journal.length, follow]);
+    // A new inbound navigation target (C1 opening a different row) re-targets selection and turns
+    // Follow off, keyed on the target's identity — not the object — so an unchanged prop re-rendered
+    // as a fresh literal never re-fires and clobbers the operator's own manual navigation.
+    useEffect(() => {
+        if (focusEvidence) {
+            setFollow(false);
+            setSelectedLine(focusEvidence.line);
+        }
+    }, [focusEvidence?.source, focusEvidence?.line]);
+    const selectedIndex = model.journal.findIndex((row) => row.evidence.line === selectedLine);
+    const selectedRow = selectedIndex >= 0 ? model.journal[selectedIndex] : undefined;
+    useInput((input, key) => {
+        if (key.leftArrow)
+            setTab((t) => TABS[(TABS.indexOf(t) - 1 + TABS.length) % TABS.length]);
+        if (key.rightArrow)
+            setTab((t) => TABS[(TABS.indexOf(t) + 1) % TABS.length]);
+        if (input === "e" && onExport)
+            onExport();
+        if (tab !== "journal" || model.journal.length === 0)
+            return;
+        if (input === "f")
+            setFollow((f) => !f);
+        if (key.upArrow) {
+            setFollow(false);
+            const i = Math.max(0, (selectedIndex < 0 ? model.journal.length - 1 : selectedIndex) - 1);
+            setSelectedLine(model.journal[i].evidence.line);
+        }
+        if (key.downArrow) {
+            setFollow(false);
+            const i = Math.min(model.journal.length - 1, (selectedIndex < 0 ? 0 : selectedIndex) + 1);
+            setSelectedLine(model.journal[i].evidence.line);
+        }
+        if (key.return && selectedRow && onSelect)
+            onSelect(selectedRow.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
+                            ? (_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))
+                    : _jsx(BodyText, { emphasis: "dim", children: "no history" }) })), tab === "stats" && (_jsx(Panel, { title: "STATS", children: model.statsLines.length
+                    ? model.statsLines.map((line, i) => _jsx(BodyText, { children: line }, i))
+                    : _jsx(BodyText, { emphasis: "dim", children: "no history" }) })), tab === "channels" && (_jsx(Panel, { title: "CHANNELS", children: model.channels.length
+                    ? model.channels.map((row) => (_jsx(BodyText, { children: formatOperatorRecordRow(row) }, row.channel)))
+                    : _jsx(BodyText, { emphasis: "dim", children: "no history" }) })), tab === "learning" && (_jsx(Panel, { title: "LEARNING PREVIEW", children: model.learningPreview.map((line, i) => _jsx(BodyText, { children: line }, i)) }))] }));
+}

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

@@ -0,0 +1,88 @@
+import { type ReactElement } from "react";
+import type { EvidenceIdentity, OperatorSnapshot, OperatorTask } from "../../run/operator-state.js";
+import { type ComponentState } from "./components.js";
+/** Rows visible in the ACTIVITY panel at once; PageUp/PageDown move the window by this many. */
+export declare const HOME_ACTIVITY_VISIBLE_ROWS = 3;
+export interface HomeSeats {
+    /** Currently dispatched/running workers — a graph-backed fact, not a config count. */
+    readonly active: number;
+    /** Configured worker-eligible channels. Kept apart from `active`: neither is derivable from the other. */
+    readonly eligible: number;
+}
+export interface HomeSpend {
+    readonly measurable: boolean;
+    /** Ignored unless `measurable`: a caller must not smuggle a `$0` display past an unmeasurable flag. */
+    readonly display?: string;
+}
+export interface HomeActivityRow {
+    /** The original journal line this row draws — never a filtered/on-screen ordinal. */
+    readonly evidence: EvidenceIdentity;
+    readonly time: string;
+    readonly state: ComponentState;
+    readonly text: string;
+}
+export interface HomeNeedsYouTarget {
+    readonly kind: "park" | "diagnostic";
+    readonly id: string;
+    readonly label: string;
+}
+export interface HomeViewInput {
+    readonly operator: OperatorSnapshot;
+    readonly seats: HomeSeats;
+    readonly spend?: HomeSpend;
+    /** Sparkline samples for the MERGED tile; absent/all-null renders "no history", never a blank ramp. */
+    readonly trend?: readonly (number | null)[];
+    readonly activity?: readonly HomeActivityRow[];
+    /** Available diagnostic targets Needs-you may offer when no park is open (e.g. a lock/read issue). */
+    readonly diagnostics?: readonly HomeNeedsYouTarget[];
+}
+export interface HomeViewModel {
+    readonly hasRun: boolean;
+    readonly lifecycle: OperatorSnapshot["lifecycle"];
+    readonly label: string;
+    readonly green: boolean;
+    readonly comparable: boolean;
+    readonly merged: number;
+    readonly planned?: number;
+    /** A comparable graph with zero tasks: distinct from "not comparable" and from 100%. */
+    readonly noPlan: boolean;
+    readonly trend: readonly (number | null)[];
+    readonly gatesRan: {
+        readonly passed: number;
+        readonly total: number;
+    };
+    readonly gatePassRate?: number;
+    readonly currentTip: OperatorSnapshot["currentTip"];
+    readonly buckets: OperatorSnapshot["buckets"];
+    readonly seats: HomeSeats;
+    readonly spend: HomeSpend;
+    readonly humanCount: number;
+    readonly blockedCount: number;
+    readonly needsYou: readonly HomeNeedsYouTarget[];
+    readonly activity: readonly HomeActivityRow[];
+    readonly runningTask?: OperatorTask;
+    readonly progressPercent?: number;
+    readonly progressCaption: string;
+}
+/**
+ * Pure C2-to-Home mapping. Needs-you reads LIVE task state (not the closed
+ * run's buckets, which the fold clears on resume) so a park stays actionable
+ * for an active/resumed run, not only a finished one.
+ */
+export declare function deriveHomeView(input: HomeViewInput): HomeViewModel;
+/** The park/diagnostic Needs-you would open right now, or undefined when nothing needs the operator. */
+export declare function selectNeedsYouTarget(model: HomeViewModel, index?: number): HomeNeedsYouTarget | undefined;
+/** The original evidence a given activity row opens, however far outside the visible window it sits. */
+export declare function selectActivityTarget(model: HomeViewModel, index: number): EvidenceIdentity | undefined;
+export interface HomeViewProps {
+    readonly model: HomeViewModel;
+    readonly width?: number | string;
+    /** Whether Home currently owns local input; a shell showing another view passes false. */
+    readonly focused?: boolean;
+    readonly onOpenPark: (taskId: string) => void;
+    readonly onOpenDiagnostic: (id: string) => void;
+    readonly onOpenEvidence: (evidence: EvidenceIdentity) => void;
+    readonly onSelectNeedsYou?: (target: HomeNeedsYouTarget | undefined, index: number) => void;
+}
+/** The exported Home body: C1 mounts this against a live HomeViewModel and its own navigation callbacks. */
+export declare function HomeView({ model, width, focused, onOpenPark, onOpenDiagnostic, onOpenEvidence, onSelectNeedsYou, }: HomeViewProps): ReactElement;

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

@@ -0,0 +1,240 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, useInput } from "ink";
+import { useLayoutEffect, useState } from "react";
+import { GLYPHS } from "../../brand.js";
+import { BodyText, CockpitGrid, Panel, ProgressMeter, Sparkline, StateGlyph, } from "./components.js";
+import { ABSENT_FIELD, fieldReading } from "./derive.js";
+/** Rows visible in the ACTIVITY panel at once; PageUp/PageDown move the window by this many. */
+export const HOME_ACTIVITY_VISIBLE_ROWS = 3;
+const parkLabel = (task) => `${task.id} ${task.parkKind ?? task.state}`;
+/**
+ * Pure C2-to-Home mapping. Needs-you reads LIVE task state (not the closed
+ * run's buckets, which the fold clears on resume) so a park stays actionable
+ * for an active/resumed run, not only a finished one.
+ */
+export function deriveHomeView(input) {
+    const { operator } = input;
+    const hasRun = operator.lifecycle !== "UNKNOWN";
+    const humanTasks = operator.tasks.filter((t) => t.state === "human");
+    const blockedTasks = operator.tasks.filter((t) => t.state === "blocked");
+    const parks = [...humanTasks, ...blockedTasks].map((t) => ({
+        kind: "park",
+        id: t.id,
+        label: parkLabel(t),
+    }));
+    const diagnostics = (input.diagnostics ?? []).filter((d) => d.id.trim().length > 0);
+    const needsYou = [...parks, ...diagnostics];
+    const planned = operator.comparable ? operator.planned : undefined;
+    const noPlan = operator.comparable && planned === 0;
+    const gatePassRate = operator.gatesRan.total > 0
+        ? Math.round((operator.gatesRan.passed / operator.gatesRan.total) * 100)
+        : undefined;
+    const runningTask = operator.tasks.find((t) => t.state === "running");
+    const progressPercent = planned && planned > 0
+        ? Math.round((operator.merged / planned) * 100)
+        : undefined;
+    const progressCaption = !hasRun
+        ? ""
+        : noPlan
+            ? "no plan"
+            : !operator.comparable
+                ? "not comparable"
+                : `worker ${fieldReading(runningTask?.id)} | attempt ${fieldReading(runningTask?.attempt)}`;
+    return {
+        hasRun,
+        lifecycle: operator.lifecycle,
+        label: operator.label,
+        green: operator.green,
+        comparable: operator.comparable,
+        merged: operator.merged,
+        planned,
+        noPlan,
+        trend: input.trend ?? [],
+        gatesRan: operator.gatesRan,
+        gatePassRate,
+        currentTip: operator.currentTip,
+        buckets: operator.buckets,
+        seats: input.seats,
+        // A caller marking spend unmeasurable may still carry a stale `display`; discard it so an
+        // all-subscription/no-telemetry fixture can never surface as a measured $0.
+        spend: input.spend?.measurable ? input.spend : { measurable: false },
+        humanCount: humanTasks.length,
+        blockedCount: blockedTasks.length,
+        needsYou,
+        activity: input.activity ?? [],
+        runningTask,
+        progressPercent,
+        progressCaption,
+    };
+}
+/** The park/diagnostic Needs-you would open right now, or undefined when nothing needs the operator. */
+export function selectNeedsYouTarget(model, index = 0) {
+    if (model.needsYou.length === 0)
+        return undefined;
+    const safeIndex = Math.min(Math.max(0, index), model.needsYou.length - 1);
+    return model.needsYou[safeIndex];
+}
+/** The original evidence a given activity row opens, however far outside the visible window it sits. */
+export function selectActivityTarget(model, index) {
+    return model.activity[index]?.evidence;
+}
+const hasTrend = (trend) => trend.some((sample) => typeof sample === "number");
+function Tile({ label, children }) {
+    return _jsx(Panel, { title: label, flexGrow: 1, children: children });
+}
+/** The exported Home body: C1 mounts this against a live HomeViewModel and its own navigation callbacks. */
+export function HomeView({ model, width, focused = true, onOpenPark, onOpenDiagnostic, onOpenEvidence, onSelectNeedsYou, }) {
+    const [offset, setOffset] = useState(0);
+    const [selectedEvidenceId, setSelectedEvidenceId] = useState(() => model.activity[0]?.evidence.id);
+    const [activityIndex, setActivityIndex] = useState(0);
+    const [selectedNeedsYouId, setSelectedNeedsYouId] = useState(() => model.needsYou[0]?.id);
+    const [needsYouIndex, setNeedsYouIndex] = useState(0);
+    const [section, setSection] = useState(model.needsYou.length > 0 ? "needsYou" : "activity");
+    // Reconcile Needs-you selection against model updates by stable target id.
+    let effectiveNeedsYouIndex = 0;
+    if (model.needsYou.length > 0) {
+        const found = selectedNeedsYouId !== undefined
+            ? model.needsYou.findIndex((t) => t.id === selectedNeedsYouId)
+            : -1;
+        if (found >= 0) {
+            effectiveNeedsYouIndex = found;
+        }
+        else {
+            effectiveNeedsYouIndex = Math.min(Math.max(0, needsYouIndex), model.needsYou.length - 1);
+        }
+    }
+    const selectedNeedsYou = selectNeedsYouTarget(model, effectiveNeedsYouIndex);
+    // Reconcile Activity selection against model updates by stable evidence id.
+    let effectiveActivityIndex = 0;
+    if (model.activity.length > 0) {
+        const found = selectedEvidenceId !== undefined
+            ? model.activity.findIndex((r) => r.evidence.id === selectedEvidenceId)
+            : -1;
+        if (found >= 0) {
+            effectiveActivityIndex = found;
+        }
+        else {
+            effectiveActivityIndex = Math.min(Math.max(0, activityIndex), model.activity.length - 1);
+        }
+    }
+    useLayoutEffect(() => {
+        if (model.needsYou.length > 0) {
+            const currentTargetId = model.needsYou[effectiveNeedsYouIndex]?.id;
+            if (currentTargetId !== selectedNeedsYouId) {
+                setSelectedNeedsYouId(currentTargetId);
+            }
+            if (effectiveNeedsYouIndex !== needsYouIndex) {
+                setNeedsYouIndex(effectiveNeedsYouIndex);
+            }
+        }
+        onSelectNeedsYou?.(selectedNeedsYou, effectiveNeedsYouIndex);
+    }, [selectedNeedsYou?.id, effectiveNeedsYouIndex, onSelectNeedsYou]);
+    useLayoutEffect(() => {
+        if (model.activity.length > 0) {
+            const currentEvidenceId = model.activity[effectiveActivityIndex]?.evidence.id;
+            if (currentEvidenceId !== selectedEvidenceId) {
+                setSelectedEvidenceId(currentEvidenceId);
+            }
+            if (effectiveActivityIndex !== activityIndex) {
+                setActivityIndex(effectiveActivityIndex);
+            }
+        }
+    }, [model.activity, effectiveActivityIndex]);
+    const effectiveSection = model.needsYou.length > 0 ? section : "activity";
+    // The offset can reach the very last row (a short final page), not just the last full window —
+    // otherwise the oldest row could never become the one Enter opens.
+    const maxOffset = Math.max(0, model.activity.length - 1);
+    const maxSelection = Math.max(0, model.activity.length - 1);
+    const safeOffset = Math.min(offset, maxOffset);
+    useInput((_input, key) => {
+        if (key.leftArrow && model.needsYou.length > 0) {
+            if (effectiveSection === "needsYou") {
+                const nextIndex = (effectiveNeedsYouIndex + 1) % model.needsYou.length;
+                setNeedsYouIndex(nextIndex);
+                setSelectedNeedsYouId(model.needsYou[nextIndex]?.id);
+            }
+            else {
+                setSection("needsYou");
+            }
+        }
+        if (key.rightArrow)
+            setSection("activity");
+        if (key.upArrow) {
+            if (effectiveSection === "needsYou") {
+                if (model.needsYou.length > 0) {
+                    const nextIndex = (effectiveNeedsYouIndex - 1 + model.needsYou.length) % model.needsYou.length;
+                    setNeedsYouIndex(nextIndex);
+                    setSelectedNeedsYouId(model.needsYou[nextIndex]?.id);
+                }
+            }
+            else {
+                if (model.activity.length > 0) {
+                    const nextIndex = Math.max(0, effectiveActivityIndex - 1);
+                    setActivityIndex(nextIndex);
+                    setSelectedEvidenceId(model.activity[nextIndex]?.evidence.id);
+                }
+            }
+        }
+        if (key.downArrow) {
+            if (effectiveSection === "needsYou") {
+                if (model.needsYou.length > 0) {
+                    const nextIndex = (effectiveNeedsYouIndex + 1) % model.needsYou.length;
+                    setNeedsYouIndex(nextIndex);
+                    setSelectedNeedsYouId(model.needsYou[nextIndex]?.id);
+                }
+            }
+            else {
+                if (model.activity.length > 0) {
+                    const nextIndex = Math.min(maxSelection, effectiveActivityIndex + 1);
+                    setActivityIndex(nextIndex);
+                    setSelectedEvidenceId(model.activity[nextIndex]?.evidence.id);
+                }
+            }
+        }
+        if (key.pageDown) {
+            setOffset((o) => Math.max(0, o - HOME_ACTIVITY_VISIBLE_ROWS));
+            if (model.activity.length > 0) {
+                const nextIndex = Math.max(0, effectiveActivityIndex - HOME_ACTIVITY_VISIBLE_ROWS);
+                setActivityIndex(nextIndex);
+                setSelectedEvidenceId(model.activity[nextIndex]?.evidence.id);
+            }
+        }
+        if (key.pageUp) {
+            setOffset((o) => Math.min(maxOffset, o + HOME_ACTIVITY_VISIBLE_ROWS));
+            if (model.activity.length > 0) {
+                const nextIndex = Math.min(maxSelection, effectiveActivityIndex + HOME_ACTIVITY_VISIBLE_ROWS);
+                setActivityIndex(nextIndex);
+                setSelectedEvidenceId(model.activity[nextIndex]?.evidence.id);
+            }
+        }
+        if (key.return) {
+            if (effectiveSection === "needsYou") {
+                const target = selectedNeedsYou;
+                if (target)
+                    (target.kind === "park" ? onOpenPark : onOpenDiagnostic)(target.id);
+            }
+            else {
+                const row = model.activity[effectiveActivityIndex];
+                if (row)
+                    onOpenEvidence(row.evidence);
+            }
+        }
+    }, { isActive: focused });
+    if (!model.hasRun) {
+        return (_jsxs(Panel, { title: "HOME", width: width, children: [_jsx(BodyText, { children: "No run recorded yet." }), _jsx(BodyText, { children: "tickmarkr fleet \u2014 review installed models" }), _jsx(BodyText, { children: "tickmarkr plan \u2014 preview routing for a spec" })] }));
+    }
+    const mergedValue = model.noPlan ? "no plan" : `${model.merged} / ${fieldReading(model.planned)}`;
+    const gatePassRateValue = model.gatePassRate === undefined ? "no history" : `${model.gatePassRate}%`;
+    const spendValue = model.spend.measurable ? model.spend.display ?? ABSENT_FIELD : "not measurable";
+    const visibleActivity = model.activity.slice(safeOffset, safeOffset + HOME_ACTIVITY_VISIBLE_ROWS);
+    return (_jsxs(Box, { flexDirection: "column", width: width, children: [_jsxs(BodyText, { emphasis: "strong", children: ["HOME / ", model.lifecycle] }), _jsxs(CockpitGrid, { children: [_jsxs(Tile, { label: "MERGED", children: [_jsx(BodyText, { emphasis: "strong", children: mergedValue }), hasTrend(model.trend)
+                                ? _jsx(Sparkline, { samples: model.trend })
+                                : _jsx(BodyText, { emphasis: "dim", children: "no history" })] }), _jsx(Tile, { label: "GATES RAN (historical)", children: _jsxs(BodyText, { emphasis: "strong", children: [model.gatesRan.passed, " / ", model.gatesRan.total] }) }), _jsx(Tile, { label: "GATE PASS RATE (historical)", children: _jsx(BodyText, { emphasis: "strong", children: gatePassRateValue }) })] }), _jsxs(CockpitGrid, { children: [_jsxs(Tile, { label: "ACTIVE SEATS", children: [_jsxs(BodyText, { emphasis: "strong", children: [model.seats.active, " active"] }), _jsxs(BodyText, { emphasis: "dim", children: [model.seats.eligible, " eligible channels"] })] }), _jsxs(Tile, { label: "NEEDS YOU", children: [_jsxs(BodyText, { emphasis: effectiveSection === "needsYou" ? "strong" : "normal", children: [model.humanCount, " parks; ", model.blockedCount, " blocked"] }), selectedNeedsYou && _jsx(BodyText, { emphasis: "dim", children: selectedNeedsYou.label })] }), _jsx(Tile, { label: "SPEND", children: _jsx(BodyText, { emphasis: "strong", children: spendValue }) })] }), _jsxs(Panel, { title: "PROGRESS", children: [model.progressPercent === undefined
+                        ? _jsx(BodyText, { children: model.progressCaption })
+                        : (_jsxs(_Fragment, { children: [_jsx(ProgressMeter, { value: model.progressPercent }), _jsx(BodyText, { emphasis: "dim", children: model.progressCaption })] })), _jsxs(BodyText, { children: ["CURRENT TIP: ", model.currentTip.toUpperCase()] })] }), _jsxs(Panel, { title: "ACTIVITY", focused: effectiveSection === "activity", children: [visibleActivity.length === 0
+                        ? _jsx(BodyText, { emphasis: "dim", children: "no history" })
+                        : visibleActivity.map((row, index) => {
+                            const isSelected = effectiveSection === "activity" && (safeOffset + index === effectiveActivityIndex);
+                            return (_jsxs(Box, { flexDirection: "row", children: [_jsx(BodyText, { emphasis: "dim", children: row.time }), _jsx(BodyText, { children: " " }), _jsx(StateGlyph, { state: row.state }), _jsxs(BodyText, { children: [" ", isSelected ? `${GLYPHS.pointer} ` : "", row.text] })] }, row.evidence.id));
+                        }), _jsx(BodyText, { emphasis: "dim", children: "PageUp history | Enter opens original journal line" })] })] }));
+}

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

@@ -19,6 +19,10 @@ export type RunKeyEvent = {
         readonly escape?: boolean;
         readonly backspace?: boolean;
         readonly delete?: boolean;
+        readonly pageUp?: boolean;
+        readonly pageDown?: boolean;
+        readonly shift?: boolean;
+        readonly meta?: boolean;
         readonly ctrl?: boolean;
     };
 };
@@ -242,3 +246,124 @@ export declare function dispatchRunSurfaceKey(event: RunKeyEvent, surface: RunSu
 export declare function resolveSetupKeyBinding(bindings: readonly SetupKeyBinding[], event: RunKeyEvent): SetupKeyBinding | undefined;
 /** Send a key event through the setup half of the shared surface registry. */
 export declare function dispatchSetupKey(event: RunKeyEvent, state: SetupInteractionState, bindings?: readonly SetupKeyBinding[]): SetupInteractionState | undefined;
+/** Installed FINAL actions, shared by shell dispatch, help and pointer buttons. */
+export declare const SHELL_BINDINGS: readonly [{
+    readonly key: "1";
+    readonly label: "Home";
+    readonly action: "home";
+}, {
+    readonly key: "4";
+    readonly label: "Run";
+    readonly action: "run";
+}, {
+    readonly key: "5";
+    readonly label: "Evidence";
+    readonly action: "evidence";
+}, {
+    readonly key: "Tab";
+    readonly label: "Focus";
+    readonly action: "focus";
+}, {
+    readonly key: "Enter";
+    readonly label: "Open";
+    readonly action: "open";
+}, {
+    readonly key: "a";
+    readonly label: "Actions";
+    readonly action: "actions";
+}, {
+    readonly key: "/";
+    readonly label: "Filter";
+    readonly action: "filter";
+}, {
+    readonly key: "e";
+    readonly label: "Export";
+    readonly action: "export";
+}, {
+    readonly key: "f";
+    readonly label: "Follow";
+    readonly action: "follow";
+}, {
+    readonly key: "PageUp/PageDown";
+    readonly label: "Page";
+    readonly action: "page";
+}, {
+    readonly key: "?";
+    readonly label: "Keys";
+    readonly action: "help";
+}, {
+    readonly key: "q";
+    readonly label: "Quit";
+    readonly action: "quit";
+}, {
+    readonly key: "+";
+    readonly label: "Widen shortcuts";
+    readonly action: "widen";
+}, {
+    readonly key: "-";
+    readonly label: "Narrow shortcuts";
+    readonly action: "narrow";
+}];
+/** Advertise only installed operations with a target in this view. */
+export declare function shellBindings(context: {
+    view: string;
+    evidenceSection?: number;
+    canOpen?: boolean;
+    canResize?: boolean;
+}): ({
+    readonly key: "1";
+    readonly label: "Home";
+    readonly action: "home";
+} | {
+    readonly key: "4";
+    readonly label: "Run";
+    readonly action: "run";
+} | {
+    readonly key: "5";
+    readonly label: "Evidence";
+    readonly action: "evidence";
+} | {
+    readonly key: "Tab";
+    readonly label: "Focus";
+    readonly action: "focus";
+} | {
+    readonly key: "Enter";
+    readonly label: "Open";
+    readonly action: "open";
+} | {
+    readonly key: "a";
+    readonly label: "Actions";
+    readonly action: "actions";
+} | {
+    readonly key: "/";
+    readonly label: "Filter";
+    readonly action: "filter";
+} | {
+    readonly key: "e";
+    readonly label: "Export";
+    readonly action: "export";
+} | {
+    readonly key: "f";
+    readonly label: "Follow";
+    readonly action: "follow";
+} | {
+    readonly key: "PageUp/PageDown";
+    readonly label: "Page";
+    readonly action: "page";
+} | {
+    readonly key: "?";
+    readonly label: "Keys";
+    readonly action: "help";
+} | {
+    readonly key: "q";
+    readonly label: "Quit";
+    readonly action: "quit";
+} | {
+    readonly key: "+";
+    readonly label: "Widen shortcuts";
+    readonly action: "widen";
+} | {
+    readonly key: "-";
+    readonly label: "Narrow shortcuts";
+    readonly action: "narrow";
+})[];