tickmarkr 1.78.0 → 1.80.0

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

@@ -0,0 +1,488 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box } from "ink";
+import { cloneElement, } from "react";
+import { parse } from "yaml";
+import { BANNER, GLYPHS, PLAIN_BANNER, } from "../../brand.js";
+import { DEFAULT_CONFIG, INTEGRITY_FLOOR_SHAPES, TIER_RANK, TickmarkrConfigSchema, unifiedYamlDiff, } from "../../config/config.js";
+import { SHAPES } from "../../graph/schema.js";
+import { allocateBandColumns, BandLines, BodyText, CockpitGrid, composeBandLine, JournalRowPanel, KEYBAR_KEYS, Keybar, measureBandRows, Panel, StateGlyph, StatTile, StatusStrip, } from "./components.js";
+import { FULL_JOURNAL_ROWS, resolveCockpitLayout, } from "./layout.js";
+import { deriveRunCockpitData, PANEL_CHROME_ROWS, panelRows, wrappedRows, } from "./run-cockpit.js";
+const APPROVED_SIDE_RAIL_COLUMN_FLOOR = 80;
+function deepMerge(base, overlay) {
+    if (overlay === undefined || overlay === null)
+        return base;
+    if (Array.isArray(base)
+        || Array.isArray(overlay)
+        || typeof base !== "object"
+        || typeof overlay !== "object"
+        || base === null) {
+        return overlay;
+    }
+    const merged = {
+        ...base,
+    };
+    for (const [key, value] of Object.entries(overlay)) {
+        if (value === null) {
+            delete merged[key];
+            continue;
+        }
+        merged[key] = key in merged
+            ? deepMerge(merged[key], value)
+            : deepMerge({}, value);
+    }
+    return merged;
+}
+function floorEdits(layers) {
+    const explicit = new Set();
+    const tombstoned = new Set();
+    for (const layer of layers) {
+        const floors = layer?.routing?.floors;
+        if (!floors || Array.isArray(floors))
+            continue;
+        for (const [shape, value] of Object.entries(floors)) {
+            if (value === null) {
+                explicit.delete(shape);
+                tombstoned.add(shape);
+            }
+            else {
+                tombstoned.delete(shape);
+                explicit.add(shape);
+            }
+        }
+    }
+    return { explicit, tombstoned };
+}
+function lowerTier(tier) {
+    return tier === "frontier" ? "mid" : "cheap";
+}
+function integrityMinimum(shape) {
+    return INTEGRITY_FLOOR_SHAPES.includes(shape)
+        ? "frontier"
+        : "cheap";
+}
+function presetFloor(mode, shape, base) {
+    if (mode === "partner-led")
+        return "frontier";
+    if (mode === "risk-based")
+        return base;
+    const lowered = lowerTier(base);
+    const minimum = integrityMinimum(shape);
+    return TIER_RANK[lowered] >= TIER_RANK[minimum] ? lowered : minimum;
+}
+function resolveCapturedConfig(captures) {
+    const globalLayer = parse(captures.config.global.raw);
+    const repoLayer = parse(captures.config.repo.raw);
+    const parsed = TickmarkrConfigSchema.parse(deepMerge(deepMerge(structuredClone(DEFAULT_CONFIG), globalLayer), repoLayer));
+    const mode = parsed.routing.mode ?? "risk-based";
+    const edits = floorEdits([globalLayer, repoLayer]);
+    for (const shape of SHAPES) {
+        if (edits.tombstoned.has(shape) || edits.explicit.has(shape))
+            continue;
+        parsed.routing.floors[shape] = presetFloor(mode, shape, DEFAULT_CONFIG.routing.floors[shape]);
+    }
+    if (mode === "partner-led") {
+        parsed.routing.explore = { ...parsed.routing.explore, mode: "off" };
+    }
+    return parsed;
+}
+function stagedPaths(value, path = []) {
+    if (value === null
+        || Array.isArray(value)
+        || typeof value !== "object") {
+        return path.length > 0 ? [path.join(".")] : [];
+    }
+    return Object.entries(value).flatMap(([key, child]) => stagedPaths(child, [...path, key]));
+}
+function deniedReason(reason) {
+    if (!reason)
+        return "channel denied access";
+    return reason.match(/Invalid params: "[^"]+"/)?.[0]
+        ?? reason.split(/\.\s+Run\b/, 1)[0]
+        ?? reason;
+}
+export function deriveSetupCockpitData(captures, binaryVersion) {
+    const harnessHealth = Object.entries(captures.doctor.data)
+        .filter(([id]) => id !== "autoPrefer")
+        .map(([id, raw]) => [id, raw]);
+    const harnesses = harnessHealth.map(([id, health]) => {
+        const models = new Set([
+            ...(health.models ?? []),
+            ...Object.keys(health.modelAuth ?? {}),
+        ]);
+        const state = health.installed !== true
+            ? "inactive"
+            : health.authed === true
+                ? "pass"
+                : "fail";
+        return {
+            id,
+            version: health.version ?? "not installed",
+            modelCount: models.size,
+            state,
+            stateWord: state === "pass" ? "authed"
+                : state === "inactive" ? "missing"
+                    : "unauthed",
+        };
+    });
+    const deniedChannels = harnessHealth.flatMap(([id, health]) => Object.entries(health.modelAuth ?? {}).flatMap(([model, verdict]) => verdict.authed === false
+        ? [{
+                channel: `${id}:${model}`,
+                reason: deniedReason(verdict.reason),
+            }]
+        : []));
+    const authenticated = harnessHealth.filter(([, health]) => health.installed === true && health.authed === true).length;
+    const routable = harnessHealth.filter(([, health]) => health.installed === true
+        && health.authed === true
+        && Object.values(health.modelAuth ?? {}).some((model) => model.authed === true)).length;
+    const repoLayer = parse(captures.config.repo.raw);
+    const reviewSource = captures.journals.find((capture) => capture.fileName === "run-20260724-231138.journal.jsonl");
+    if (!reviewSource)
+        throw new Error("healthy cockpit capture is missing");
+    return {
+        binaryVersion,
+        harnesses,
+        deniedChannels,
+        counts: {
+            found: harnesses.length,
+            authenticated,
+            routable,
+        },
+        config: resolveCapturedConfig(captures),
+        overlayDiff: unifiedYamlDiff(captures.config.global.raw, captures.config.repo.raw, captures.config.repo.fileName),
+        stagedChanges: stagedPaths(repoLayer),
+        reviewRows: deriveRunCockpitData(reviewSource, binaryVersion).journalRows,
+        overlayTarget: captures.config.repo.fileName,
+    };
+}
+function identityBannerLines() {
+    return (process.env.NO_COLOR === undefined ? BANNER : PLAIN_BANNER).trimEnd().split("\n");
+}
+function identityVersionLines(data) {
+    return [`v${data.binaryVersion} · binary ${GLYPHS.pass}`, "setup · step 2/6"];
+}
+function IdentityHeader({ data, secondary = true, }) {
+    const mark = identityBannerLines();
+    const [version, step] = identityVersionLines(data);
+    return (_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Box, { flexDirection: "column", children: (secondary ? mark : mark.slice(0, 1)).map((line, index) => (_jsx(BodyText, { emphasis: "strong", children: line }, `${index}:${line}`))) }), _jsxs(Box, { flexDirection: "column", alignItems: "flex-end", children: [_jsx(BodyText, { emphasis: "strong", children: version }), secondary && _jsx(BodyText, { children: step })] })] }));
+}
+function NavigationPanel({ width = 16, compact = false, }) {
+    if (!compact) {
+        return (_jsxs(Panel, { title: "SETUP", width: width, children: [_jsx(BodyText, { children: "  Detect" }), _jsxs(BodyText, { emphasis: "strong", children: [GLYPHS.pointer, " Harnesses"] }), _jsx(BodyText, { children: "  Fleet" }), _jsx(BodyText, { children: "  Gates" }), _jsx(BodyText, { children: "  Consults" }), _jsx(BodyText, { children: "  Reviewers" }), _jsx(BodyText, { children: "  Review" })] }));
+    }
+    return (_jsxs(Panel, { title: "SETUP", width: width, children: [_jsx(Box, { height: 1, overflow: "hidden", children: _jsx(BodyText, { children: "  Detect" }) }), _jsx(Box, { height: 1, overflow: "hidden", children: _jsxs(BodyText, { emphasis: "strong", children: [GLYPHS.pointer, " Harnesses"] }) }), _jsx(Box, { height: 1, overflow: "hidden", children: _jsx(BodyText, { children: "  Fleet" }) }), _jsx(Box, { height: 1, overflow: "hidden", children: _jsx(BodyText, { children: "  Gates" }) }), _jsx(Box, { height: 1, overflow: "hidden", children: _jsx(BodyText, { children: "  Consults" }) }), _jsx(Box, { height: 1, overflow: "hidden", children: _jsx(BodyText, { children: "  Reviewers" }) }), _jsx(Box, { height: 1, overflow: "hidden", children: _jsx(BodyText, { children: "  Review" }) })] }));
+}
+function KeysPanel({ width = 16 }) {
+    return (_jsx(Panel, { title: "KEYS", width: width, children: KEYBAR_KEYS.setup.map((item) => (_jsxs(Box, { children: [_jsx(BodyText, { emphasis: "strong", children: item.key }), _jsxs(BodyText, { children: [" ", item.label] })] }, item.key))) }));
+}
+function CompactKeysPanel({ width = 16 }) {
+    const contentColumns = Math.max(1, width - 4);
+    return (_jsx(Panel, { title: "KEYS", width: width, children: KEYBAR_KEYS.setupAdditional.map((item) => (_jsxs(Box, { flexDirection: "row", flexWrap: "nowrap", height: 1, overflow: "hidden", children: [_jsx(BodyText, { emphasis: "strong", children: item.key }), _jsxs(BodyText, { children: [" ", item.label.slice(0, Math.max(0, contentColumns - [...item.key].length - 1))] })] }, item.key))) }));
+}
+function fullKeysFit(rows, layout, data, columns) {
+    if (!layout.elements.secondaryHeader)
+        return false;
+    const wrappedKeyRows = {
+        "three-column": 0,
+        "folded-keys": 2,
+        stacked: 4,
+    }[layout.arrangement];
+    const panelRows = KEYBAR_KEYS.setup.length
+        + wrappedKeyRows
+        + 3; // panel borders and title row
+    return headerRowsFor(layout, data, columns) + 2 + panelRows <= Math.floor(rows);
+}
+function sidePanelWidth(layout) {
+    if (layout.arrangement === "three-column")
+        return 16;
+    if (layout.arrangement === "folded-keys")
+        return 12;
+    return 11;
+}
+/**
+ * Every detail panel publishes the body lines it draws, so the height ladder
+ * can charge it the rows those very lines occupy rather than a constant that
+ * goes stale the moment the panel changes.
+ */
+function detectedRows(data) {
+    return [
+        ...data.harnesses.map((harness) => ({
+            key: harness.id,
+            state: harness.state,
+            text: ` ${harness.stateWord} · ${harness.id} · ${harness.version}`
+                + ` · ${harness.modelCount} models`,
+        })),
+        ...data.deniedChannels.map((denied) => ({
+            key: denied.channel,
+            state: "fail",
+            text: ` denied · ${denied.channel} — ${denied.reason}`,
+        })),
+    ];
+}
+function fleetLines(data) {
+    const routing = data.config.routing;
+    return [
+        `mode ${routing.mode ?? "risk-based"}`,
+        `floors ${Object.entries(routing.floors)
+            .map(([shape, tier]) => `${shape}:${tier}`)
+            .join(" · ")}`,
+        `deny ${(routing.deny?.models ?? []).join(", ") || "none"}`,
+    ];
+}
+function gatesLines(data) {
+    return [
+        `test ${data.config.gates.test ?? "auto-detected"}`,
+        `diff cap ${data.config.gates.diffCap}`,
+    ];
+}
+function consultsLines(data) {
+    const consult = data.config.consult;
+    return [
+        `seat ${consult.adapter}:${consult.model}`,
+        `stall ${consult.stallMinutes} minutes`,
+        ...(consult.prefer ?? []).map((seat) => `prefer ${seat}`),
+    ];
+}
+function reviewersLines(data) {
+    const review = data.config.review;
+    return [
+        `required ${String(review.required)}`,
+        `complexity threshold ${review.complexityThreshold}`,
+        ...(review.prefer ?? []).map((reviewer) => `prefer ${reviewer}`),
+    ];
+}
+function overlayDiffLines(data) {
+    const lines = data.overlayDiff.split("\n");
+    return [
+        ...lines.slice(0, 2),
+        ...lines.filter((line) => line.startsWith("-") && !line.startsWith("---")).slice(0, 2),
+        ...lines.filter((line) => line.startsWith("+") && !line.startsWith("+++")).slice(0, 4),
+    ];
+}
+function HarnessRows({ rows, columns, }) {
+    return (_jsx(Panel, { title: "DETECTED", children: rows.flatMap((row) => {
+            const [first = "", ...continuations] = composeBandLine(row.text.trimStart(), Math.max(1, columns));
+            return [
+                _jsxs(Box, { children: [_jsx(StateGlyph, { state: row.state }), _jsxs(BodyText, { children: [" ", first] })] }, row.key),
+                ...continuations.map((line, index) => (_jsx(BodyText, { children: line }, `${row.key}:continuation:${index}`))),
+            ];
+        }) }));
+}
+function LinePanel({ title, lines, columns, emphasis, }) {
+    return (_jsx(Panel, { title: title, children: _jsx(BandLines, { lines: lines, columns: columns, emphasis: emphasis }) }));
+}
+function lineBandContent(title, lines) {
+    return { title, lines };
+}
+function LineBand({ columns, panels, }) {
+    const widths = allocateBandColumns(columns, panels);
+    return (_jsx(CockpitGrid, { columns: columns, columnContents: panels, children: panels.map((panel, index) => (_jsx(LinePanel, { title: panel.title, lines: panel.lines, columns: Math.max(1, widths[index] - 4) }, panel.title))) }));
+}
+function statsSummaryLine(data) {
+    return `found ${data.counts.found} · authenticated ${data.counts.authenticated}`
+        + ` · routable ${data.counts.routable}`;
+}
+function SetupStats({ data, mode, }) {
+    if (mode === "summary") {
+        return _jsx(BodyText, { children: statsSummaryLine(data) });
+    }
+    return (_jsxs(CockpitGrid, { children: [_jsx(StatTile, { label: "FOUND", value: data.counts.found, samples: [data.counts.found] }), _jsx(StatTile, { label: "AUTHENTICATED", value: data.counts.authenticated, samples: [data.counts.authenticated] }), _jsx(StatTile, { label: "ROUTABLE", value: data.counts.routable, samples: [data.counts.routable] })] }));
+}
+function SizedReviewPanel({ rows, bodyRows, }) {
+    const visible = rows.slice(0, bodyRows);
+    const emptyRows = Math.max(0, bodyRows - visible.length);
+    const review = JournalRowPanel({ rows: visible, title: "REVIEW" });
+    const reviewProps = review.props;
+    return cloneElement(review, {}, reviewProps.children, emptyRows > 0 ? _jsx(Box, { height: emptyRows }, "review-space") : null);
+}
+/**
+ * The contracted ladder (§5.4) governs the elements every surface shares. The
+ * detail panels below it are the setup body, so they surrender first, from the
+ * bottom of this list upward: what a step is *about* outlives what merely
+ * describes the fleet.
+ */
+export const SETUP_DETAIL_ORDER = [
+    "detected",
+    "consultsAndReviewers",
+    "overlayDiff",
+    "fleetAndGates",
+];
+/** Columns the HARNESSES panel gives its body, after side rails and chrome. */
+function contentInnerWidth(columns, layout) {
+    const rails = Math.floor(columns) >= APPROVED_SIDE_RAIL_COLUMN_FLOOR
+        ? 2 * sidePanelWidth(layout) + 2 // both rails and the gaps beside them
+        : 0;
+    return Math.max(1, Math.floor(columns) - rails - 4);
+}
+function gridRows(panels, inner) {
+    return measureBandRows(inner, panels);
+}
+function detailRows(detail, data, inner) {
+    switch (detail) {
+        case "consultsAndReviewers":
+            return gridRows([
+                lineBandContent("CONSULTS", consultsLines(data)),
+                lineBandContent("REVIEWERS", reviewersLines(data)),
+            ], inner);
+        case "overlayDiff":
+            return panelRows(overlayDiffLines(data), inner - 4);
+        case "fleetAndGates":
+            return gridRows([
+                lineBandContent("FLEET", fleetLines(data)),
+                lineBandContent("GATES", gatesLines(data)),
+            ], inner);
+    }
+}
+/** Every detected row spends its first two columns on the state glyph and gap. */
+function detectedPanelRows(rows, inner) {
+    const columns = Math.max(1, inner - 6);
+    return PANEL_CHROME_ROWS + rows.reduce((total, row) => total + composeBandLine(row.text.trimStart(), columns).length, 0);
+}
+/**
+ * DETECTED is the body of the step the surface is showing, so — like the
+ * journal body it stands in for (§5.4 rank 5) — it shrinks rather than being
+ * replaced: it gives up rows from the bottom, never below one row per state it
+ * still has to report, and only disappears when even that will not fit.
+ */
+function detectedPlan(data, inner, budget) {
+    const all = detectedRows(data);
+    if (detectedPanelRows(all, inner) <= budget)
+        return all;
+    const states = new Set();
+    const smallest = all.filter((row) => {
+        if (states.has(row.state))
+            return false;
+        states.add(row.state);
+        return true;
+    });
+    if (detectedPanelRows(smallest, inner) > budget)
+        return [];
+    // Grow back toward the full panel, keeping the panel's own row order.
+    const kept = new Set(smallest);
+    for (const row of all) {
+        if (kept.has(row))
+            continue;
+        const grown = all.filter((candidate) => kept.has(candidate) || candidate === row);
+        if (detectedPanelRows(grown, inner) > budget)
+            break;
+        kept.add(row);
+    }
+    return all.filter((row) => kept.has(row));
+}
+function setupDetailPlan(rows, data, inner, base, journalPreferred) {
+    // DETECTED may borrow from the review body down to its one-row minimum; the
+    // configuration panels below it may not.
+    const detected = detectedPlan(data, inner, Math.max(0, Math.floor(rows) - base - 1));
+    const retained = new Set(detected.length > 0 ? ["detected"] : []);
+    let retainedRows = detected.length > 0
+        ? detectedPanelRows(detected, inner)
+        : 0;
+    let available = Math.max(0, Math.floor(rows) - base - journalPreferred - retainedRows);
+    for (const detail of SETUP_DETAIL_ORDER.slice(1)) {
+        const cost = detailRows(detail, data, inner);
+        if (available < cost)
+            break;
+        retained.add(detail);
+        retainedRows += cost;
+        available -= cost;
+    }
+    return {
+        detected,
+        retained,
+        retainedRows,
+        complete: retained.size === SETUP_DETAIL_ORDER.length
+            && detected.length === detectedRows(data).length,
+    };
+}
+function versionColumnWidth(data) {
+    return Math.max(...identityVersionLines(data).map((line) => [...line].length));
+}
+/**
+ * The banner sits beside the version column, so a narrow frame leaves it fewer
+ * columns and it wraps. Charged from the banner the header actually draws.
+ */
+function headerRowsFor(layout, data, columns) {
+    if (!layout.elements.secondaryHeader)
+        return 1;
+    const banner = Math.max(1, Math.floor(columns) - versionColumnWidth(data));
+    return identityBannerLines().reduce((rows, line) => rows + wrappedRows(line, banner), 0);
+}
+function statRowsFor(layout, data, inner) {
+    // A tile is its value, its sparkline and its chrome; the stacked band spends
+    // one more row because the widest label wraps.
+    if (layout.stats.mode === "tiles") {
+        return PANEL_CHROME_ROWS + 2 + (layout.arrangement === "stacked" ? 1 : 0);
+    }
+    return wrappedRows(statsSummaryLine(data), inner);
+}
+/** Every row the frame spends before the detail panels and the review body. */
+function baseRows(layout, data, columns, inner) {
+    return headerRowsFor(layout, data, columns)
+        + 2 // permanent status strip and keybar
+        + 3 // outer HARNESSES panel border and title
+        + statRowsFor(layout, data, inner)
+        + PANEL_CHROME_ROWS; // review border and title
+}
+function LadderSetupPanel({ data, layout, columns, rows, }) {
+    const inner = contentInnerWidth(columns, layout);
+    const preferredReviewRows = Math.min(FULL_JOURNAL_ROWS, layout.journalRows);
+    const base = baseRows(layout, data, columns, inner);
+    const details = setupDetailPlan(rows, data, inner, base, preferredReviewRows);
+    const spare = Math.max(1, Math.floor(rows) - base - details.retainedRows);
+    // Once the whole arrangement is drawn the review body is the only sink left,
+    // so it absorbs the surplus; below that it holds its contracted height.
+    const visibleReviewRows = details.complete
+        ? spare
+        : Math.min(preferredReviewRows, spare);
+    return (_jsxs(Panel, { title: "HARNESSES", focused: true, flexGrow: 1, children: [_jsx(SetupStats, { data: data, mode: layout.stats.mode }), details.retained.has("detected") && (_jsx(HarnessRows, { rows: details.detected, columns: Math.max(1, inner - 6) })), details.retained.has("fleetAndGates") && (_jsx(LineBand, { columns: inner, panels: [
+                    lineBandContent("FLEET", fleetLines(data)),
+                    lineBandContent("GATES", gatesLines(data)),
+                ] })), details.retained.has("consultsAndReviewers") && (_jsx(LineBand, { columns: inner, panels: [
+                    lineBandContent("CONSULTS", consultsLines(data)),
+                    lineBandContent("REVIEWERS", reviewersLines(data)),
+                ] })), details.retained.has("overlayDiff") && (_jsx(LinePanel, { title: "OVERLAY DIFF", lines: overlayDiffLines(data), columns: Math.max(1, inner - 4), emphasis: "dim" })), _jsx(SizedReviewPanel, { rows: data.reviewRows, bodyRows: visibleReviewRows })] }));
+}
+function SetupPanel({ data, inner, }) {
+    return (_jsxs(Panel, { title: "HARNESSES", focused: true, flexGrow: 1, children: [_jsxs(CockpitGrid, { children: [_jsx(StatTile, { label: "FOUND", value: data.counts.found, samples: [data.counts.found] }), _jsx(StatTile, { label: "AUTHENTICATED", value: data.counts.authenticated, samples: [data.counts.authenticated] }), _jsx(StatTile, { label: "ROUTABLE", value: data.counts.routable, samples: [data.counts.routable] })] }), _jsx(HarnessRows, { rows: detectedRows(data), columns: Math.max(1, inner - 6) }), _jsx(LineBand, { columns: inner, panels: [
+                    lineBandContent("FLEET", fleetLines(data)),
+                    lineBandContent("GATES", gatesLines(data)),
+                ] }), _jsx(LineBand, { columns: inner, panels: [
+                    lineBandContent("CONSULTS", consultsLines(data)),
+                    lineBandContent("REVIEWERS", reviewersLines(data)),
+                ] }), _jsx(LinePanel, { title: "OVERLAY DIFF", lines: overlayDiffLines(data), columns: Math.max(1, inner - 4), emphasis: "dim" }), _jsx(SizedReviewPanel, { rows: data.reviewRows, bodyRows: data.reviewRows.length })] }));
+}
+export function SetupCockpitFrame({ data, columns, rows, }) {
+    if (rows === undefined) {
+        const inner = Math.max(1, Math.floor(columns) - (2 * 16) - 2 - 4);
+        return (_jsxs(Box, { flexDirection: "column", width: columns, children: [_jsx(IdentityHeader, { data: data }), _jsxs(Box, { flexDirection: "row", gap: 1, children: [_jsx(NavigationPanel, {}), _jsx(SetupPanel, { data: data, inner: inner }), _jsx(KeysPanel, {})] }), _jsx(StatusStrip, { width: columns, items: [
+                        { state: "neutral", text: `overlay ${data.overlayTarget}` },
+                        { state: "pass", text: "base untouched" },
+                        {
+                            state: "warn",
+                            text: `${data.stagedChanges.length} changes unsaved`,
+                        },
+                    ] }), _jsx(Keybar, { surface: "setup", width: columns })] }));
+    }
+    const layout = resolveCockpitLayout(columns, rows);
+    if (layout.renderer === "plain")
+        return _jsx(_Fragment, {});
+    const showSideRails = columns >= APPROVED_SIDE_RAIL_COLUMN_FLOOR;
+    const contentLayout = showSideRails
+        ? layout
+        : {
+            ...layout,
+            stats: { ...layout.stats, mode: "summary", rows: 1 },
+        };
+    const showFullSidePanels = fullKeysFit(rows, contentLayout, data, columns);
+    const resolvedSidePanelWidth = sidePanelWidth(contentLayout);
+    return (_jsxs(Box, { flexDirection: "column", width: columns, children: [_jsx(IdentityHeader, { data: data, secondary: layout.elements.secondaryHeader }), _jsxs(Box, { flexDirection: "row", gap: showSideRails ? 1 : 0, children: [showSideRails && (_jsx(Box, { width: resolvedSidePanelWidth, flexShrink: 0, children: _jsx(NavigationPanel, { width: resolvedSidePanelWidth, compact: !contentLayout.elements.secondaryHeader }) })), _jsx(LadderSetupPanel, { data: data, layout: contentLayout, columns: columns, rows: rows }), showSideRails && (showFullSidePanels
+                        ? (_jsx(Box, { width: resolvedSidePanelWidth, flexShrink: 0, children: _jsx(KeysPanel, { width: resolvedSidePanelWidth }) }))
+                        : (_jsx(Box, { width: resolvedSidePanelWidth, flexShrink: 0, children: _jsx(CompactKeysPanel, { width: resolvedSidePanelWidth }) })))] }), _jsx(StatusStrip, { width: columns, items: [
+                    { state: "neutral", text: `overlay ${data.overlayTarget}` },
+                    { state: "pass", text: "base untouched" },
+                    {
+                        state: "warn",
+                        text: `${data.stagedChanges.length} changes unsaved`,
+                    },
+                ] }), _jsx(Keybar, { surface: "setup", width: columns })] }));
+}

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

@@ -0,0 +1,161 @@
+export type HexColour = `#${string}`;
+export type ColourValue = {
+    readonly xterm: number;
+    readonly hex: HexColour;
+};
+/** The logo remains governed by src/brand.ts; cockpit data never modifies this ramp. */
+export declare const LOGO_RAMP: readonly [84, 78, 41, 35];
+/** Near-black panel fill against which every data shade must remain legible. */
+export declare const COCKPIT_SURFACE: "#1a1a19";
+/** Bright-to-deep, single-hue data ink. Depth communicates magnitude, never tile identity. */
+export declare const COCKPIT_DATA_RAMP: readonly [{
+    readonly xterm: 84;
+    readonly hex: "#5fff5f";
+}, {
+    readonly xterm: 41;
+    readonly hex: "#00d75f";
+}, {
+    readonly xterm: 35;
+    readonly hex: "#00af5f";
+}, {
+    readonly xterm: 29;
+    readonly hex: "#00875f";
+}];
+/** Documented near-misses retained as guard fixtures, not special cases in the guard. */
+export declare const EXCLUDED_DATA_SHADES: {
+    readonly neighbourCollision: {
+        readonly xterm: 78;
+        readonly hex: "#5fd787";
+    };
+    readonly insufficientContrast: {
+        readonly xterm: 22;
+        readonly hex: "#005f00";
+    };
+};
+/**
+ * The only coloured semantic inks outside the green ramp. Shape and text make
+ * both meanings survive NO_COLOR and reduced-colour terminals.
+ */
+export declare const COCKPIT_INKS: {
+    readonly dataRamp: readonly [{
+        readonly xterm: 84;
+        readonly hex: "#5fff5f";
+    }, {
+        readonly xterm: 41;
+        readonly hex: "#00d75f";
+    }, {
+        readonly xterm: 35;
+        readonly hex: "#00af5f";
+    }, {
+        readonly xterm: 29;
+        readonly hex: "#00875f";
+    }];
+    readonly warning: {
+        readonly xterm: 214;
+        readonly hex: "#ffaf00";
+        readonly glyph: "!";
+        readonly label: "warning";
+    };
+    readonly failure: {
+        readonly xterm: 203;
+        readonly hex: "#ff5f5f";
+        readonly glyph: "✗";
+        readonly label: "failure";
+    };
+};
+/** Every drawable cockpit ink; the panel surface and text emphasis are not inks. */
+export declare const COCKPIT_INK_VOCABULARY: readonly [{
+    readonly xterm: 84;
+    readonly hex: "#5fff5f";
+}, {
+    readonly xterm: 41;
+    readonly hex: "#00d75f";
+}, {
+    readonly xterm: 35;
+    readonly hex: "#00af5f";
+}, {
+    readonly xterm: 29;
+    readonly hex: "#00875f";
+}, {
+    readonly xterm: 214;
+    readonly hex: "#ffaf00";
+    readonly glyph: "!";
+    readonly label: "warning";
+}, {
+    readonly xterm: 203;
+    readonly hex: "#ff5f5f";
+    readonly glyph: "✗";
+    readonly label: "failure";
+}];
+/** Text hierarchy is independent of hue: weight and dimming are its only axes. */
+export declare const TEXT_EMPHASIS_TOKENS: {
+    readonly strong: {
+        readonly weight: "bold";
+        readonly dimmed: false;
+    };
+    readonly normal: {
+        readonly weight: "normal";
+        readonly dimmed: false;
+    };
+    readonly dim: {
+        readonly weight: "normal";
+        readonly dimmed: true;
+    };
+};
+/** Deliberate 16-colour choices. Renderers select this map; they do not infer one. */
+export declare const REDUCED_COLOUR_MAPPING: {
+    readonly dataRamp: readonly [{
+        readonly from: "#5fff5f";
+        readonly to: "bright-green";
+    }, {
+        readonly from: "#00d75f";
+        readonly to: "green";
+    }, {
+        readonly from: "#00af5f";
+        readonly to: "green";
+    }, {
+        readonly from: "#00875f";
+        readonly to: "dim-green";
+    }];
+    readonly warning: {
+        readonly from: "#ffaf00";
+        readonly to: "yellow";
+    };
+    readonly failure: {
+        readonly from: "#ff5f5f";
+        readonly to: "red";
+    };
+};
+export type TileMagnitude = 0 | 1 | 2 | 3;
+export type TileColourInput = {
+    readonly magnitude: TileMagnitude;
+};
+/**
+ * Resolve reusable tile ink from magnitude alone. Tile names and positions are
+ * deliberately absent from the contract, so separate tiles cannot acquire identity hues.
+ */
+export declare function resolveTileColour({ magnitude }: TileColourInput): (typeof COCKPIT_DATA_RAMP)[number];
+export declare const DATA_RAMP_GUARD: {
+    readonly requiredSteps: 4;
+    readonly minimumContrast: 3;
+    readonly minimumNeighbourDistance: 0.08;
+    readonly maximumLightnessStepSpread: 0.02;
+};
+export type PaletteGuardIssueKind = "step-count" | "invalid-colour" | "lightness-order" | "lightness-spacing" | "neighbour-collision" | "contrast";
+export type PaletteGuardIssue = {
+    readonly kind: PaletteGuardIssueKind;
+    readonly indexes: readonly number[];
+};
+export type PaletteGuardVerdict = {
+    readonly ok: boolean;
+    readonly lightness: readonly number[];
+    readonly lightnessSteps: readonly number[];
+    readonly neighbourDistances: readonly number[];
+    readonly contrastRatios: readonly number[];
+    readonly issues: readonly PaletteGuardIssue[];
+};
+/**
+ * Evaluate any four candidate values. Xterm indexes and declared palette names
+ * are intentionally ignored: only parsed colour values can earn a verdict.
+ */
+export declare function guardDataRamp(candidate: readonly ColourValue[], surface?: HexColour): PaletteGuardVerdict;