tickmarkr 1.79.0 → 1.81.0

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

@@ -0,0 +1,532 @@
+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, 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";
+import { initialSetupInteractionState, keybarEntries, SETUP_PANEL_FOCUS_ORDER, SURFACE_KEY_BINDINGS, } from "./keys.js";
+const APPROVED_SIDE_RAIL_COLUMN_FLOOR = 80;
+const setupAdditionalBindings = (bindings) => bindings.filter((binding) => !SURFACE_KEY_BINDINGS.run.some((runBinding) => runBinding.key === binding.key));
+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, interaction) {
+    return [
+        `v${data.binaryVersion} · binary ${GLYPHS.pass}`,
+        `setup · step ${interaction?.step ?? 2}/6`,
+    ];
+}
+function IdentityHeader({ data, secondary = true, interaction, }) {
+    const mark = identityBannerLines();
+    const [version, step] = identityVersionLines(data, interaction);
+    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, step = 2, focused = false, }) {
+    const entries = [
+        "Detect",
+        "Harnesses",
+        "Fleet",
+        "Gates",
+        "Consults",
+        "Reviewers",
+        "Review",
+    ];
+    if (!compact) {
+        return (_jsx(Panel, { title: "SETUP", width: width, focused: focused, children: entries.map((entry, index) => (_jsxs(BodyText, { emphasis: index + 1 === step ? "strong" : "normal", children: [index + 1 === step ? `${GLYPHS.pointer} ` : "  ", entry] }, entry))) }));
+    }
+    return (_jsx(Panel, { title: "SETUP", width: width, focused: focused, children: entries.map((entry, index) => (_jsx(Box, { height: 1, overflow: "hidden", children: _jsxs(BodyText, { emphasis: index + 1 === step ? "strong" : "normal", children: [index + 1 === step ? `${GLYPHS.pointer} ` : "  ", entry] }) }, entry))) }));
+}
+function KeysPanel({ bindings, width = 16, focused = false, }) {
+    return (_jsx(Panel, { title: "KEYS", width: width, focused: focused, children: keybarEntries(bindings).map((item) => (_jsxs(Box, { children: [_jsx(BodyText, { emphasis: "strong", children: item.key }), _jsxs(BodyText, { children: [" ", item.label] })] }, item.key))) }));
+}
+function CompactKeysPanel({ bindings, width = 16, focused = false, }) {
+    const contentColumns = Math.max(1, width - 4);
+    return (_jsx(Panel, { title: "KEYS", width: width, focused: focused, children: keybarEntries(setupAdditionalBindings(bindings)).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 SetupKeybar({ bindings, width, }) {
+    return (_jsx(Box, { flexDirection: "row", flexWrap: "nowrap", width: width, height: 1, overflow: "hidden", "aria-label": "setup cockpit keys", children: keybarEntries(bindings).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))) }));
+}
+function SetupInteractionPanel({ data, interaction, bindings, }) {
+    if (interaction?.savePrompt === true) {
+        return (_jsx(LinePanel, { title: "SAVE", lines: ["confirm save · y yes · n cancel", ...overlayDiffLines(data)], columns: 72 }));
+    }
+    if (interaction?.help === true) {
+        return (_jsx(LinePanel, { title: "HELP", lines: keybarEntries(bindings).map((item) => `${item.key} ${item.label}`), columns: 72 }));
+    }
+    return null;
+}
+function setupStatusItems(data, interaction) {
+    const items = [
+        { state: "neutral", text: `overlay ${data.overlayTarget}` },
+        { state: "pass", text: "base untouched" },
+        interaction?.saved === true
+            ? { state: "active", text: "changes saved" }
+            : { state: "warn", text: `${data.stagedChanges.length} changes unsaved` },
+    ];
+    if (interaction !== undefined) {
+        if (interaction.all)
+            items.push({ state: "active", text: "all selected" });
+        else if (interaction.selected.length > 0) {
+            items.push({ state: "active", text: "selection selected" });
+        }
+        else if (interaction.selection >= 0) {
+            items.push({ state: "neutral", text: `selection ${interaction.selection + 1}` });
+        }
+        if (interaction.probeRevision > 0) {
+            items.push({ state: "pass", text: `re-probed ${interaction.probeRevision}` });
+        }
+        if (interaction.panel !== 1) {
+            const panel = SETUP_PANEL_FOCUS_ORDER[interaction.panel] ?? "HARNESSES";
+            items.push({ state: "neutral", text: `panel ${panel}` });
+        }
+    }
+    return items;
+}
+function fullKeysFit(rows, layout, data, columns, bindings) {
+    if (!layout.elements.secondaryHeader)
+        return false;
+    const wrappedKeyRows = {
+        "three-column": 0,
+        "folded-keys": 2,
+        stacked: 4,
+    }[layout.arrangement];
+    const panelRows = bindings.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, interaction, bindings, focused = true, }) {
+    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);
+    const interactionPanel = SetupInteractionPanel({ data, interaction, bindings });
+    return (_jsx(Panel, { title: "HARNESSES", focused: focused, flexGrow: 1, children: interactionPanel ?? (_jsxs(_Fragment, { 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, interaction, bindings, focused = true, }) {
+    const interactionPanel = SetupInteractionPanel({ data, interaction, bindings });
+    return (_jsx(Panel, { title: "HARNESSES", focused: focused, flexGrow: 1, children: interactionPanel ?? (_jsxs(_Fragment, { 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, interaction, bindings = SURFACE_KEY_BINDINGS.setup, }) {
+    const currentInteraction = interaction ?? initialSetupInteractionState();
+    const focusedPanel = SETUP_PANEL_FOCUS_ORDER[currentInteraction.panel]
+        ?? "HARNESSES";
+    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, interaction: currentInteraction }), _jsxs(Box, { flexDirection: "row", gap: 1, children: [_jsx(NavigationPanel, { step: currentInteraction.step, focused: focusedPanel === "SETUP" }), _jsx(SetupPanel, { data: data, inner: inner, interaction: currentInteraction, bindings: bindings, focused: focusedPanel === "HARNESSES" }), _jsx(KeysPanel, { bindings: bindings, focused: focusedPanel === "KEYS" })] }), _jsx(StatusStrip, { width: columns, items: setupStatusItems(data, currentInteraction) }), _jsx(SetupKeybar, { bindings: bindings, 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, bindings);
+    const resolvedSidePanelWidth = sidePanelWidth(contentLayout);
+    return (_jsxs(Box, { flexDirection: "column", width: columns, children: [_jsx(IdentityHeader, { data: data, secondary: layout.elements.secondaryHeader, interaction: currentInteraction }), _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, step: currentInteraction.step, focused: focusedPanel === "SETUP" }) })), _jsx(LadderSetupPanel, { data: data, layout: contentLayout, columns: columns, rows: rows, interaction: currentInteraction, bindings: bindings, focused: focusedPanel === "HARNESSES" }), showSideRails && (showFullSidePanels
+                        ? (_jsx(Box, { width: resolvedSidePanelWidth, flexShrink: 0, children: _jsx(KeysPanel, { bindings: bindings, width: resolvedSidePanelWidth, focused: focusedPanel === "KEYS" }) }))
+                        : (_jsx(Box, { width: resolvedSidePanelWidth, flexShrink: 0, children: _jsx(CompactKeysPanel, { bindings: bindings, width: resolvedSidePanelWidth, focused: focusedPanel === "KEYS" }) })))] }), _jsx(StatusStrip, { width: columns, items: setupStatusItems(data, currentInteraction) }), _jsx(SetupKeybar, { bindings: bindings, width: columns })] }));
+}