tmux-ide 2.8.0 → 2.9.0-beta.6

package/packages/daemon/dist/tui/mirror/missions-workspace.js

@@ -0,0 +1,1399 @@
+import { findFirstHostedViewForPanel, terminalDisplayWidth } from "./panel-host.js";
+import { clipTerminal } from "./terminal-text.js";
+import { missionsSelection, setMissionsNavigation, setMissionsSelection, viewStateFor, } from "./workspace-ui-state.js";
+// Compatibility for callers that already import mission-specific helpers from
+// this module. Generic surfaces should import from terminal-text directly.
+export { clipTerminal } from "./terminal-text.js";
+export const MISSION_BOARD_COLUMNS = ["planned", "running", "blocked", "review", "done"];
+export const MISSION_COLUMN_LABELS = {
+    planned: "Planned",
+    running: "Running",
+    blocked: "Blocked",
+    review: "Review",
+    done: "Done",
+};
+export const MISSION_COLUMN_SHORT_LABELS = {
+    planned: "Pl",
+    running: "Ru",
+    blocked: "Bl",
+    review: "Re",
+    done: "Do",
+};
+export const MISSION_DENSITIES = ["compact", "comfortable", "detailed"];
+export const MISSION_MIN_COLUMN_WIDTH = 22;
+export const MISSION_MAX_COLUMN_WIDTH = 34;
+export const MISSION_COLLAPSED_COLUMN_WIDTH = 8;
+export const MISSION_COLUMN_GAP = 1;
+export const MISSION_HEADER_ROWS = 2;
+export const MISSION_FOOTER_ROWS = 1;
+export const MISSION_DETAIL_SECTIONS = ["tasks", "timeline", "attempts", "proof"];
+export function invalidatedMissionWorkspaceLoadState() {
+    return { status: "loading", generation: 0, projectKey: null };
+}
+export function defaultMissionWorkspaceModel(selectedMissionId = null, selectedTaskId = null) {
+    return {
+        mode: "board",
+        density: "comfortable",
+        selectedMissionId,
+        selectedColumn: "planned",
+        preferredRow: 0,
+        columnScroll: emptyScrolls(),
+        historyScroll: 0,
+        horizontalOffset: 0,
+        detailReturnMode: "board",
+        selectedTaskId,
+        detailSection: "tasks",
+        detailScroll: emptyDetailScrolls(),
+        collapsedColumns: emptyCollapsedColumns(),
+        zoomColumn: null,
+        zoomRestoreHorizontalOffset: null,
+    };
+}
+export function reconcileMissionWorkspaceModel(model, snapshot, options = {}) {
+    let next = cloneModel(model);
+    const preferred = options.persistedMissionId ?? next.selectedMissionId;
+    if (!snapshot) {
+        next.selectedMissionId = preferred ?? null;
+        next.selectedTaskId = options.persistedTaskId ?? next.selectedTaskId ?? null;
+        return next;
+    }
+    if (next.mode === "detail") {
+        const detailMission = snapshot.detail?.mission.id;
+        if (detailMission) {
+            next.selectedMissionId = detailMission;
+            next.selectedTaskId = selectDetailTask(snapshot.detail, detailMission === model.selectedMissionId
+                ? (next.selectedTaskId ?? options.persistedTaskId)
+                : options.persistedTaskId);
+            return clampMissionWorkspaceModel(next, snapshot, options);
+        }
+        if (missionExists(snapshot, next.selectedMissionId)) {
+            return clampMissionWorkspaceModel(next, snapshot, options);
+        }
+        next.mode = next.detailReturnMode;
+        next.selectedTaskId = null;
+    }
+    if (next.mode === "history") {
+        next.selectedMissionId = selectHistoryMission(snapshot.history, preferred);
+        next.historyScroll = clampTop(next.historyScroll, snapshot.history.length, historyItemCapacity(options.height, next.density));
+        return clampMissionWorkspaceModel(next, snapshot, options);
+    }
+    const found = findMissionInBoard(snapshot.board, preferred);
+    const fallback = found ?? firstBoardMission(snapshot.board);
+    next.selectedMissionId = fallback?.id ?? null;
+    next.selectedColumn = fallback?.column ?? next.selectedColumn;
+    next.preferredRow = fallback?.index ?? 0;
+    return clampMissionWorkspaceModel(next, snapshot, options);
+}
+export function clampMissionWorkspaceModel(model, snapshot, options = {}) {
+    const next = cloneModel(model);
+    const rows = boardItemCapacity(options.height, next.density);
+    for (const column of MISSION_BOARD_COLUMNS) {
+        next.columnScroll[column] = clampTop(next.columnScroll[column], snapshot.board.columns[column].length, rows);
+    }
+    const selected = findMissionInBoard(snapshot.board, next.selectedMissionId);
+    if (selected) {
+        next.selectedColumn = selected.column;
+        next.preferredRow = selected.index;
+        if (next.zoomColumn)
+            next.zoomColumn = selected.column;
+        next.columnScroll[selected.column] = scrollToIndex(selected.index, next.columnScroll[selected.column], rows);
+        next.horizontalOffset = followColumnOffset(columnIndex(selected.column), next.horizontalOffset, options.width, next);
+    }
+    else if (next.mode === "board") {
+        const fallback = firstBoardMission(snapshot.board);
+        next.selectedMissionId = fallback?.id ?? null;
+        next.selectedColumn = fallback?.column ?? next.selectedColumn;
+        next.preferredRow = fallback?.index ?? 0;
+        if (fallback) {
+            next.horizontalOffset = followColumnOffset(columnIndex(fallback.column), next.horizontalOffset, options.width, next);
+        }
+    }
+    if (next.mode === "history") {
+        next.selectedMissionId = selectHistoryMission(snapshot.history, next.selectedMissionId);
+        const idx = snapshot.history.findIndex((entry) => entry.mission.id === next.selectedMissionId);
+        if (idx >= 0)
+            next.historyScroll = scrollToIndex(idx, next.historyScroll, historyItemCapacity(options.height, next.density));
+        next.historyScroll = clampTop(next.historyScroll, snapshot.history.length, historyItemCapacity(options.height, next.density));
+    }
+    if (next.mode === "detail" && snapshot.detail) {
+        next.selectedTaskId = selectDetailTask(snapshot.detail, next.selectedTaskId);
+        for (const section of MISSION_DETAIL_SECTIONS) {
+            const itemCount = detailSectionItems(snapshot.detail, section).length;
+            next.detailScroll[section] = clampTop(next.detailScroll[section], itemCount, effectiveDetailItemCapacity(options.width, options.height, next.density, itemCount));
+        }
+        if (next.detailSection === "tasks") {
+            const idx = flattenedTasks(snapshot.detail).findIndex((task) => task.id === next.selectedTaskId);
+            if (idx >= 0) {
+                const itemCount = flattenedTasks(snapshot.detail).length;
+                next.detailScroll.tasks = scrollToIndex(idx, next.detailScroll.tasks, effectiveDetailItemCapacity(options.width, options.height, next.density, itemCount));
+            }
+        }
+    }
+    next.horizontalOffset = Math.min(Math.max(0, next.horizontalOffset), missionBoardWindow(options.width ?? 120, next).maxOffset);
+    return next;
+}
+export function moveMissionSelection(model, snapshot, action, options = {}) {
+    const next = cloneModel(model);
+    if (next.mode === "detail")
+        return moveMissionDetailSelection(next, snapshot, action, options);
+    if (next.mode === "history") {
+        const current = Math.max(0, snapshot.history.findIndex((entry) => entry.mission.id === next.selectedMissionId));
+        const last = Math.max(0, snapshot.history.length - 1);
+        const index = action === "up"
+            ? Math.max(0, current - 1)
+            : action === "down"
+                ? Math.min(last, current + 1)
+                : action === "home"
+                    ? 0
+                    : action === "end"
+                        ? last
+                        : current;
+        next.selectedMissionId = snapshot.history[index]?.mission.id ?? null;
+        return clampMissionWorkspaceModel(next, snapshot, options);
+    }
+    const located = findMissionInBoard(snapshot.board, next.selectedMissionId);
+    const currentColumn = located?.column ?? next.selectedColumn;
+    const currentIndex = located?.index ?? next.preferredRow;
+    if (action === "up" || action === "down" || action === "home" || action === "end") {
+        const cards = snapshot.board.columns[currentColumn];
+        if (cards.length > 0) {
+            const index = action === "up"
+                ? Math.max(0, currentIndex - 1)
+                : action === "down"
+                    ? Math.min(cards.length - 1, currentIndex + 1)
+                    : action === "home"
+                        ? 0
+                        : cards.length - 1;
+            next.selectedMissionId = cards[index]?.id ?? null;
+            next.selectedColumn = currentColumn;
+            next.preferredRow = index;
+        }
+    }
+    else {
+        const target = nearestNonEmptyColumn(snapshot.board, currentColumn, action === "left" ? -1 : 1);
+        if (target) {
+            const cards = snapshot.board.columns[target];
+            const index = Math.min(currentIndex, cards.length - 1);
+            next.selectedMissionId = cards[index]?.id ?? null;
+            next.selectedColumn = target;
+            next.preferredRow = index;
+        }
+    }
+    return clampMissionWorkspaceModel(next, snapshot, options);
+}
+export function setMissionWorkspaceMode(model, snapshot, mode, options = {}) {
+    return reconcileMissionWorkspaceModel({ ...cloneModel(model), mode }, snapshot, options);
+}
+export function cycleMissionDensity(model, snapshot, options = {}) {
+    const index = MISSION_DENSITIES.indexOf(model.density);
+    const next = {
+        ...cloneModel(model),
+        density: MISSION_DENSITIES[(index + 1) % MISSION_DENSITIES.length],
+    };
+    return snapshot ? clampMissionWorkspaceModel(next, snapshot, options) : next;
+}
+export function toggleMissionColumnCollapse(model, snapshot, options = {}) {
+    const next = cloneModel(model);
+    const column = next.selectedColumn;
+    next.collapsedColumns[column] = !next.collapsedColumns[column];
+    if (next.collapsedColumns[column] && next.zoomColumn === column) {
+        next.zoomColumn = null;
+        next.horizontalOffset = next.zoomRestoreHorizontalOffset ?? next.horizontalOffset;
+        next.zoomRestoreHorizontalOffset = null;
+    }
+    return snapshot ? clampMissionWorkspaceModel(next, snapshot, options) : next;
+}
+export function toggleMissionColumnZoom(model, snapshot, options = {}) {
+    const next = cloneModel(model);
+    if (next.mode !== "board")
+        return next;
+    if (next.zoomColumn) {
+        const restore = next.zoomRestoreHorizontalOffset ?? next.horizontalOffset;
+        next.zoomColumn = null;
+        next.zoomRestoreHorizontalOffset = null;
+        const clamped = snapshot ? clampMissionWorkspaceModel(next, snapshot, options) : next;
+        clamped.horizontalOffset = Math.min(Math.max(0, restore), missionBoardWindow(options.width ?? 120, clamped).maxOffset);
+        return clamped;
+    }
+    else {
+        next.zoomColumn = next.selectedColumn;
+        next.zoomRestoreHorizontalOffset = next.horizontalOffset;
+        next.collapsedColumns[next.selectedColumn] = false;
+    }
+    return snapshot ? clampMissionWorkspaceModel(next, snapshot, options) : next;
+}
+export function scrollMissionWorkspace(model, snapshot, target, delta, options = {}) {
+    const next = cloneModel(model);
+    if (isDetailSection(target))
+        next.detailScroll[target] += delta;
+    else if (target === "history")
+        next.historyScroll += delta;
+    else
+        next.columnScroll[target] += delta;
+    return clampMissionWorkspaceModel(next, snapshot, options);
+}
+export function applyMissionWorkspaceHit(model, snapshot, hit, options = {}) {
+    if (hit.kind === "mode")
+        return setMissionWorkspaceMode(model, snapshot, hit.mode, options);
+    if (hit.kind === "density")
+        return cycleMissionDensity(model, snapshot, options);
+    if (hit.kind === "collapse")
+        return toggleMissionColumnCollapse(model, snapshot, options);
+    if (hit.kind === "zoom")
+        return toggleMissionColumnZoom(model, snapshot, options);
+    if (hit.kind === "detail-section")
+        return clampMissionWorkspaceModel({ ...cloneModel(model), detailSection: hit.section }, snapshot, options);
+    if (hit.kind === "detail-row") {
+        const next = cloneModel(model);
+        if (hit.section === "tasks")
+            next.selectedTaskId = hit.id;
+        return clampMissionWorkspaceModel(next, snapshot, options);
+    }
+    if (hit.kind === "deep-link")
+        return model;
+    if (hit.kind === "horizontal") {
+        return moveMissionSelection(model, snapshot, hit.direction < 0 ? "left" : "right", options);
+    }
+    if (hit.kind === "column") {
+        const first = snapshot.board.columns[hit.column][0];
+        return first
+            ? reconcileMissionWorkspaceModel({ ...cloneModel(model), selectedMissionId: first.id }, snapshot, options)
+            : clampMissionWorkspaceModel({ ...cloneModel(model), selectedColumn: hit.column }, snapshot, options);
+    }
+    return reconcileMissionWorkspaceModel({ ...cloneModel(model), selectedMissionId: hit.missionId }, snapshot, options);
+}
+export function openMissionDetail(model, snapshot, options = {}) {
+    if (!model.selectedMissionId)
+        return model;
+    return reconcileMissionWorkspaceModel({
+        ...cloneModel(model),
+        mode: "detail",
+        detailReturnMode: model.mode === "history" ? "history" : "board",
+        selectedTaskId: options.persistedTaskId ?? model.selectedTaskId,
+    }, snapshot, options);
+}
+export function closeMissionDetail(model) {
+    const next = cloneModel(model);
+    if (next.mode === "detail")
+        next.mode = next.detailReturnMode;
+    return next;
+}
+export function setMissionDetailSection(model, snapshot, section, options = {}) {
+    return clampMissionWorkspaceModel({ ...cloneModel(model), detailSection: section }, snapshot, options);
+}
+export function cycleMissionDetailSection(model, snapshot, direction, options = {}) {
+    const index = MISSION_DETAIL_SECTIONS.indexOf(model.detailSection);
+    const next = MISSION_DETAIL_SECTIONS[(index + direction + MISSION_DETAIL_SECTIONS.length) % MISSION_DETAIL_SECTIONS.length];
+    return setMissionDetailSection(model, snapshot, next, options);
+}
+export function missionWorkspaceLayout(width, height, model, snapshot, presentation = {}) {
+    const safeWidth = Math.max(1, width);
+    const safeHeight = Math.max(1, height);
+    const zoomColumn = model.mode === "board" ? model.zoomColumn : null;
+    const packedWindow = missionBoardWindow(safeWidth, model);
+    const visibleColumns = packedWindow.columns.map((column) => column.column);
+    const columnWidth = Math.max(1, Math.max(...packedWindow.columns.map((column) => column.width)));
+    const cardHeight = missionCardHeight(model.density);
+    const availableRows = boardRows(safeHeight);
+    const boardCapacity = boardItemCapacity(safeHeight, model.density);
+    const columns = [];
+    let x = 0;
+    for (const packed of packedWindow.columns) {
+        const column = packed.column;
+        const cards = snapshot?.board.columns[column] ?? [];
+        const start = Math.max(0, model.columnScroll[column]);
+        const collapsed = packed.collapsed && column !== zoomColumn;
+        const widthForColumn = Math.max(1, Math.min(packed.width, safeWidth - x));
+        const visibleCards = collapsed ? [] : cards.slice(start, start + boardCapacity);
+        const lane = missionLaneRect(x, widthForColumn, safeHeight);
+        const count = snapshot?.board.counts[column] ?? 0;
+        columns.push({
+            column,
+            label: MISSION_COLUMN_LABELS[column],
+            title: missionColumnTitle(column, count, collapsed, lane.bodyWidth),
+            x,
+            y: lane.y,
+            width: widthForColumn,
+            height: lane.height,
+            bodyX: lane.bodyX,
+            bodyY: lane.bodyY,
+            bodyWidth: lane.bodyWidth,
+            bodyHeight: lane.bodyHeight,
+            titleRows: lane.titleRows,
+            showTitle: lane.titleRows > 0,
+            count,
+            scroll: start,
+            active: model.selectedColumn === column,
+            collapsed,
+            zoomed: zoomColumn === column,
+            cards: visibleCards
+                .map((card, visibleIndex) => {
+                const y = lane.bodyY + visibleIndex * cardHeight;
+                const height = Math.max(0, Math.min(cardHeight, lane.bodyY + lane.bodyHeight - y));
+                return {
+                    missionId: card.id,
+                    column,
+                    index: start + visibleIndex,
+                    hoverKey: missionCardHoverKey(column, start + visibleIndex),
+                    x: lane.bodyX,
+                    y,
+                    width: lane.bodyWidth,
+                    height,
+                    lines: missionCardLines(card, model.density, lane.bodyWidth).slice(0, height),
+                };
+            })
+                .filter((card) => card.height > 0),
+        });
+        x += widthForColumn + MISSION_COLUMN_GAP;
+    }
+    const historyAvailableRows = historyRows(safeHeight);
+    const historyStart = Math.max(0, model.historyScroll);
+    const rowHeight = missionHistoryRowHeight(model.density);
+    const historyCapacity = historyItemCapacity(safeHeight, model.density);
+    const header = missionHeaderLayout(safeWidth, model, snapshot, presentation);
+    const detail = missionDetailLayout(safeWidth, safeHeight, model, snapshot?.detail ?? null);
+    return {
+        width: safeWidth,
+        height: safeHeight,
+        mode: model.mode,
+        header,
+        footer: {
+            label: missionFooterLabel(safeWidth, model, presentation.quitHint),
+            width: safeWidth,
+        },
+        board: { availableRows, itemCapacity: boardCapacity, columnWidth, visibleColumns, columns },
+        history: {
+            availableRows: historyAvailableRows,
+            itemCapacity: historyCapacity,
+            rows: (snapshot?.history ?? [])
+                .slice(historyStart, historyStart + historyCapacity)
+                .map((entry, visibleIndex) => ({
+                missionId: entry.mission.id,
+                index: historyStart + visibleIndex,
+                hoverKey: historyStart + visibleIndex,
+                x: 0,
+                y: MISSION_HEADER_ROWS + visibleIndex * rowHeight,
+                width: safeWidth,
+                height: rowHeight,
+                lines: missionHistoryLines(entry, model.density, safeWidth),
+            })),
+        },
+        detail,
+    };
+}
+export function missionWorkspaceHitTest(layout, x, y) {
+    if (y === 0) {
+        const hit = missionHeaderHit(layout.header, x, y);
+        if (hit)
+            return hit;
+    }
+    else if (y === 1) {
+        const hit = missionHeaderHit(layout.header, x, y);
+        if (hit)
+            return hit;
+    }
+    if (layout.mode === "board") {
+        for (const column of layout.board.columns) {
+            if (x >= column.x && x < column.x + column.width && y >= column.y && y < column.bodyY)
+                return { kind: "column", column: column.column };
+            for (const card of column.cards) {
+                if (x >= card.x && x < card.x + card.width && y >= card.y && y < card.y + card.height) {
+                    return {
+                        kind: "card",
+                        missionId: card.missionId,
+                        column: card.column,
+                        index: card.index,
+                        hoverKey: card.hoverKey,
+                    };
+                }
+            }
+        }
+        return null;
+    }
+    if (layout.mode === "history") {
+        for (const row of layout.history.rows) {
+            if (x >= row.x && x < row.x + row.width && y >= row.y && y < row.y + row.height) {
+                return {
+                    kind: "history",
+                    missionId: row.missionId,
+                    index: row.index,
+                    hoverKey: row.hoverKey,
+                };
+            }
+        }
+    }
+    if (layout.mode === "detail") {
+        for (const section of layout.detail.sections) {
+            if (x >= section.start && x < section.start + section.width && y === section.row) {
+                return section.section ? { kind: "detail-section", section: section.section } : null;
+            }
+        }
+        for (const link of layout.detail.links) {
+            if (x >= link.start && x < link.start + link.width && y === link.row) {
+                return link.link ? { kind: "deep-link", link: link.link } : null;
+            }
+        }
+        for (const row of layout.detail.rows) {
+            if (x >= row.x && x < row.x + row.width && y >= row.y && y < row.y + row.height) {
+                if (row.kind === "context")
+                    return null;
+                return {
+                    kind: "detail-row",
+                    section: row.kind,
+                    id: row.id,
+                    index: row.index,
+                    hoverKey: row.hoverKey,
+                };
+            }
+        }
+    }
+    return null;
+}
+export function missionCardLines(card, density, width) {
+    const progress = card.progress.total > 0 ? `${card.progress.done}/${card.progress.total}` : "no tasks";
+    const agent = card.latestAttempt?.agent ?? "";
+    const lines = [pinnedPrimaryLine(card.title, width, `${card.status} ${progress}`, agent)];
+    if (density !== "compact") {
+        lines.push(card.summary);
+        if (card.blockedBy.length > 0)
+            lines.push(`blocked by ${card.blockedBy.length}`);
+        if (card.latestAttempt)
+            lines.push(`attempt ${card.latestAttempt.agent}/${card.latestAttempt.harness}`);
+        const proof = proofSignal(card.proofSummary);
+        if (proof)
+            lines.push(proof);
+    }
+    if (density === "detailed") {
+        if (card.durationMs !== null)
+            lines.push(`duration ${formatDuration(card.durationMs)}`);
+        if (card.labels.length > 0)
+            lines.push(`# ${card.labels.join(", ")}`);
+    }
+    return lines.slice(0, missionCardHeight(density)).map((line) => clipTerminal(line, width));
+}
+export function missionHistoryLines(entry, density, width) {
+    const lines = [
+        `${entry.outcome} · ${entry.mission.title}`,
+        `finished ${entry.finishedAt} · ${entry.taskTotals.done}/${entry.taskTotals.total} tasks · ${formatDuration(entry.durationMs)}`,
+    ];
+    if (density !== "compact") {
+        lines.push(`attempts ${attemptSignals(entry)}${entry.lastEvent ? ` · ${entry.lastEvent.label}` : ""}`);
+        const proof = proofSignal(entry.proofSummary);
+        if (proof)
+            lines.push(proof);
+    }
+    if (density === "detailed")
+        lines.push(`mission ${entry.mission.id}`);
+    return lines.slice(0, missionHistoryRowHeight(density)).map((line) => clipTerminal(line, width));
+}
+export function missionDetailContextLines(detail, width) {
+    const mission = detail.mission;
+    const lines = [
+        mission.title,
+        `${mission.status} · ${detail.progress.done}/${detail.progress.total} tasks · ${formatDuration(mission.durationMs)}`,
+        mission.summary,
+    ];
+    if (mission.labels.length > 0)
+        lines.push(`# ${mission.labels.join(", ")}`);
+    if (mission.blockedBy.length > 0)
+        lines.push(`blocked by ${mission.blockedBy.join(", ")}`);
+    if (mission.latestAttempt)
+        lines.push(`latest ${mission.latestAttempt.agent}/${mission.latestAttempt.harness}`);
+    const proof = proofSignal(mission.proofSummary);
+    if (proof)
+        lines.push(proof);
+    return lines.map((line) => clipTerminal(line, width));
+}
+export function missionDetailTaskLines(task, density, width) {
+    const agent = task.latestAttempt?.agent ?? task.assignee ?? "";
+    const lines = [
+        pinnedPrimaryLine(task.title, width, `${task.status} p${task.priority}`, agent),
+        task.summary,
+    ];
+    if (density !== "compact") {
+        lines.push(`${task.column}${task.assignee ? ` · ${task.assignee}` : ""}`);
+        if (task.dependencies.length > 0)
+            lines.push(`depends ${task.dependencies.join(", ")}`);
+        if (task.blockedBy.length > 0)
+            lines.push(`blocked by ${task.blockedBy.join(", ")}`);
+        if (task.latestAttempt)
+            lines.push(`attempt ${task.latestAttempt.agent}/${task.latestAttempt.harness}${task.latestAttempt.model ? `/${task.latestAttempt.model}` : ""}`);
+        const proof = proofSignal(task.proofSummary);
+        if (proof)
+            lines.push(proof);
+    }
+    if (density === "detailed")
+        lines.push(`task ${task.id} · duration ${formatDuration(task.durationMs)}`);
+    const limit = density === "compact" ? 1 : missionDetailRowHeight(density);
+    return lines.slice(0, limit).map((line) => clipTerminal(line, width));
+}
+export function pinnedPrimaryLine(title, width, requiredMeta, agent = null) {
+    if (width <= 0)
+        return "";
+    const compactAgent = agent ? `@${agent}` : "";
+    const required = requiredMeta.trim();
+    const fullMeta = [required, compactAgent].filter(Boolean).join(" ");
+    const meta = terminalDisplayWidth(fullMeta) <= width || !required ? fullMeta : required;
+    if (terminalDisplayWidth(meta) >= width)
+        return clipTerminal(meta, width);
+    const metaWidth = terminalDisplayWidth(meta);
+    const minGap = meta.length > 0 ? 1 : 0;
+    const titleWidth = Math.max(0, width - metaWidth - minGap);
+    const clippedTitle = clipTerminal(title, titleWidth);
+    if (!clippedTitle)
+        return meta;
+    const gap = " ".repeat(Math.max(minGap, width - terminalDisplayWidth(clippedTitle) - metaWidth));
+    return clipTerminal(`${clippedTitle}${gap}${meta}`, width);
+}
+export function missionDetailTimelineLines(entry, width) {
+    const refs = [
+        entry.taskId ? `task ${entry.taskId}` : "",
+        entry.attemptId ? `attempt ${entry.attemptId}` : "",
+        entry.proofId ? `proof ${entry.proofId}` : "",
+    ].filter(Boolean);
+    return [
+        `#${entry.sequence} ${entry.timestamp} · ${entry.label}`,
+        `${entry.type} · ${entry.actor.type}:${entry.actor.id}${refs.length ? ` · ${refs.join(" · ")}` : ""}`,
+        entry.reason ? `reason ${entry.reason}` : "",
+    ]
+        .filter(Boolean)
+        .slice(0, 3)
+        .map((line) => clipTerminal(line, width));
+}
+export function missionDetailAttemptLines(attempt, density, width) {
+    const lines = [
+        `${attempt.status}${attempt.outcome ? `/${attempt.outcome}` : ""} · task ${attempt.taskId}`,
+        `${attempt.agent}/${attempt.harness}${attempt.model ? ` · ${attempt.model}` : ""} · ${formatDuration(attempt.durationMs)}`,
+    ];
+    if (density !== "compact") {
+        if (attempt.session)
+            lines.push(`session ${attempt.session}`);
+        if (attempt.terminal)
+            lines.push(`pane ${attempt.terminal}`);
+        if (attempt.worktree)
+            lines.push(`worktree ${attempt.worktree}`);
+        if (attempt.proofIds.length > 0)
+            lines.push(`${attempt.proofIds.length} proof`);
+    }
+    return lines.slice(0, missionDetailRowHeight(density)).map((line) => clipTerminal(line, width));
+}
+export function missionDetailProofLines(detail, density, width) {
+    const proof = detail.proofSummary;
+    const lines = [
+        proof.hasProof ? `${proof.proofIds.length} proof item(s)` : "no proof recorded",
+        proof.noProofReasons.length ? `no-proof ${proof.noProofReasons.join(", ")}` : "",
+        proof.notesCount > 0 ? `${proof.notesCount} note(s)` : "",
+        proof.tests.total > 0 ? `tests ${proof.tests.passed}/${proof.tests.total}` : "",
+        proof.commits.length > 0 ? `commits ${proof.commits.join(", ")}` : "",
+        proof.diff.filesChanged > 0
+            ? `diff ${proof.diff.filesChanged} files +${proof.diff.insertions}/-${proof.diff.deletions}`
+            : "",
+        proof.diff.summaries.length > 0 ? `diff ${proof.diff.summaries.join(", ")}` : "",
+        proof.prs.length > 0
+            ? `PR ${proof.prs.map((pr) => pr.number ?? pr.status ?? pr.url ?? "link").join(", ")}`
+            : "",
+        proof.artifacts.length > 0
+            ? `artifacts ${proof.artifacts.map((artifact) => artifact.name).join(", ")}`
+            : "",
+    ].filter(Boolean);
+    return lines.slice(0, missionDetailRowHeight(density)).map((line) => clipTerminal(line, width));
+}
+export function resolveMissionDeepLink(kind, detail, model, options) {
+    const label = kind === "terminal" ? "t terminal" : kind === "files" ? "f files" : "d diff";
+    if (!detail)
+        return { available: false, kind, label, reason: "mission detail is not loaded" };
+    const tasks = flattenedTasks(detail);
+    const task = tasks.length > 0 ? selectedDetailTask(detail, model.selectedTaskId) : null;
+    const attempt = task
+        ? task.latestAttempt
+        : (detail.mission.latestAttempt ?? detail.attempts[0] ?? null);
+    if (kind === "terminal") {
+        const view = findFirstHostedViewForPanel(options.views, "terminals");
+        if (!view)
+            return { available: false, kind, label, reason: "no configured Terminals view" };
+        if (!attempt?.session)
+            return { available: false, kind, label, reason: "selected task has no terminal session ref" };
+        return {
+            available: true,
+            kind,
+            label,
+            intent: {
+                kind,
+                session: attempt.session,
+                paneId: attempt.terminal ?? null,
+                viewId: view.id,
+            },
+        };
+    }
+    if (kind === "files") {
+        const view = findFirstHostedViewForPanel(options.views, "files");
+        if (!view)
+            return { available: false, kind, label, reason: "no configured Files view" };
+        const artifactPath = safeProjectedPath(task
+            ? firstProjectedFilePath(task.proofSummary)
+            : firstProjectedFilePath(detail.mission.proofSummary), options);
+        const fallbackPath = safeProjectedPath(task?.refs.worktree ?? attempt?.worktree, options);
+        const path = artifactPath ?? fallbackPath;
+        if (!path)
+            return { available: false, kind, label, reason: "no safe in-project file ref" };
+        return {
+            available: true,
+            kind,
+            label,
+            intent: {
+                kind,
+                path,
+                viewId: view.id,
+                mode: artifactPath ? "open" : "reveal",
+            },
+        };
+    }
+    const view = findFirstHostedViewForPanel(options.views, "diff");
+    if (!view)
+        return { available: false, kind, label, reason: "no configured Diff view" };
+    const path = safeProjectedPath(task?.refs.worktree ?? attempt?.worktree, options) ??
+        safeProjectedPath(task
+            ? firstProjectedFilePath(task.proofSummary)
+            : firstProjectedFilePath(detail.mission.proofSummary), options);
+    if (!path)
+        return { available: false, kind, label, reason: "no safe in-project diff ref" };
+    return { available: true, kind, label, intent: { kind, path, viewId: view.id } };
+}
+export function missionTmuxPreflightCommands(intent) {
+    const commands = [
+        { kind: "session", file: "tmux", args: ["has-session", "-t", `=${intent.session}`] },
+    ];
+    if (intent.paneId) {
+        commands.push({
+            kind: "pane",
+            file: "tmux",
+            args: ["display-message", "-p", "-t", intent.paneId, "#{session_name}\t#{pane_id}"],
+        });
+    }
+    return commands;
+}
+export function missionTmuxPanePreflightMatches(output, session, paneId) {
+    return output.trimEnd() === `${session}\t${paneId}`;
+}
+export function selectedDetailTask(detail, taskId) {
+    if (!detail)
+        return null;
+    return (flattenedTasks(detail).find((task) => task.id === taskId) ?? flattenedTasks(detail)[0] ?? null);
+}
+export function missionModeLabel(mode, active) {
+    return active ? `[${mode}]` : ` ${mode} `;
+}
+export function densityLabel(density) {
+    return `z ${density}`;
+}
+export function missionSelectionFromWorkspaceState(state, viewId) {
+    return missionsSelection(state, viewId);
+}
+export function workspaceStateWithMissionSelection(state, viewId, missionId, taskId = null) {
+    return setMissionsSelection(state, viewId, missionId, taskId);
+}
+export function missionModelFromWorkspaceState(state, view, fallback = defaultMissionWorkspaceModel()) {
+    const entry = viewStateFor(state, view);
+    if (entry?.panel !== "missions" || !entry.navigation) {
+        const selection = missionsSelection(state, view.id);
+        return {
+            ...cloneModel(fallback),
+            selectedMissionId: selection.selectedMissionId ?? fallback.selectedMissionId,
+            selectedTaskId: selection.selectedTaskId ?? fallback.selectedTaskId,
+        };
+    }
+    return {
+        ...cloneModel(fallback),
+        mode: entry.navigation.mode,
+        density: entry.navigation.density,
+        selectedMissionId: entry.selectedMissionId,
+        selectedColumn: entry.navigation.selectedColumn,
+        preferredRow: entry.navigation.preferredRow,
+        columnScroll: { ...entry.navigation.columnScroll },
+        historyScroll: entry.navigation.historyScroll,
+        horizontalOffset: entry.navigation.horizontalOffset,
+        detailReturnMode: entry.navigation.detailReturnMode,
+        selectedTaskId: entry.selectedTaskId,
+        detailSection: entry.navigation.detailSection,
+        detailScroll: { ...entry.navigation.detailScroll },
+        collapsedColumns: { ...entry.navigation.collapsedColumns },
+        zoomColumn: entry.navigation.zoomColumn,
+        zoomRestoreHorizontalOffset: entry.navigation.zoomRestoreHorizontalOffset,
+    };
+}
+export function workspaceStateWithMissionModel(state, viewId, model) {
+    return setMissionsNavigation(state, viewId, { selectedMissionId: model.selectedMissionId, selectedTaskId: model.selectedTaskId }, missionModelToNavigation(model));
+}
+function missionModelToNavigation(model) {
+    return {
+        mode: model.mode,
+        density: model.density,
+        selectedColumn: model.selectedColumn,
+        preferredRow: model.preferredRow,
+        columnScroll: { ...model.columnScroll },
+        historyScroll: model.historyScroll,
+        horizontalOffset: model.horizontalOffset,
+        detailReturnMode: model.detailReturnMode,
+        detailSection: model.detailSection,
+        detailScroll: { ...model.detailScroll },
+        collapsedColumns: { ...model.collapsedColumns },
+        zoomColumn: model.zoomColumn,
+        zoomRestoreHorizontalOffset: model.zoomRestoreHorizontalOffset,
+    };
+}
+function emptyScrolls() {
+    return { planned: 0, running: 0, blocked: 0, review: 0, done: 0 };
+}
+function emptyDetailScrolls() {
+    return { tasks: 0, timeline: 0, attempts: 0, proof: 0 };
+}
+function emptyCollapsedColumns() {
+    return { planned: false, running: false, blocked: false, review: false, done: false };
+}
+function cloneModel(model) {
+    return {
+        ...model,
+        columnScroll: { ...model.columnScroll },
+        detailScroll: { ...model.detailScroll },
+        collapsedColumns: { ...model.collapsedColumns },
+    };
+}
+function findMissionInBoard(board, missionId) {
+    if (!missionId)
+        return null;
+    for (const column of MISSION_BOARD_COLUMNS) {
+        const index = board.columns[column].findIndex((card) => card.id === missionId);
+        if (index >= 0)
+            return { id: missionId, column, index };
+    }
+    return null;
+}
+function firstBoardMission(board) {
+    for (const column of MISSION_BOARD_COLUMNS) {
+        const card = board.columns[column][0];
+        if (card)
+            return { id: card.id, column, index: 0 };
+    }
+    return null;
+}
+function missionExists(snapshot, missionId) {
+    if (!missionId)
+        return false;
+    return (!!findMissionInBoard(snapshot.board, missionId) ||
+        snapshot.history.some((entry) => entry.mission.id === missionId));
+}
+function selectHistoryMission(history, missionId) {
+    if (missionId && history.some((entry) => entry.mission.id === missionId))
+        return missionId;
+    return history[0]?.mission.id ?? null;
+}
+function selectDetailTask(detail, taskId) {
+    if (!detail)
+        return taskId ?? null;
+    const tasks = flattenedTasks(detail);
+    if (taskId && tasks.some((task) => task.id === taskId))
+        return taskId;
+    return tasks[0]?.id ?? null;
+}
+function flattenedTasks(detail) {
+    return MISSION_BOARD_COLUMNS.flatMap((column) => detail.taskBoard.columns[column]);
+}
+function isDetailSection(value) {
+    return value === "tasks" || value === "timeline" || value === "attempts" || value === "proof";
+}
+function detailSectionItems(detail, section) {
+    if (!detail)
+        return [];
+    if (section === "tasks")
+        return flattenedTasks(detail);
+    if (section === "timeline")
+        return detail.timeline;
+    if (section === "attempts")
+        return detail.attempts;
+    return [detail.proofSummary];
+}
+function firstProjectedFilePath(proof) {
+    return proof.artifacts.find((artifact) => isPlainRelativePath(artifact.uri))?.uri ?? null;
+}
+function safeProjectedPath(rawPath, options) {
+    if (!rawPath || !isPlainRelativePath(rawPath))
+        return null;
+    return options.resolveProjectPath(options.projectRoot, rawPath);
+}
+function isPlainRelativePath(value) {
+    if (/^[a-z][a-z0-9+.-]*:/iu.test(value))
+        return false;
+    if (value.startsWith("/") || value.startsWith("\\") || value.startsWith("~"))
+        return false;
+    if (value.includes("\0"))
+        return false;
+    return true;
+}
+function moveMissionDetailSelection(model, snapshot, action, options) {
+    let next = cloneModel(model);
+    if (!snapshot.detail)
+        return next;
+    if (action === "left" || action === "right") {
+        return cycleMissionDetailSection(next, snapshot, action === "left" ? -1 : 1, options);
+    }
+    const items = detailSectionItems(snapshot.detail, next.detailSection);
+    if (next.detailSection === "tasks") {
+        const tasks = flattenedTasks(snapshot.detail);
+        const current = Math.max(0, tasks.findIndex((task) => task.id === next.selectedTaskId));
+        const last = Math.max(0, tasks.length - 1);
+        const index = action === "up"
+            ? Math.max(0, current - 1)
+            : action === "down"
+                ? Math.min(last, current + 1)
+                : action === "home"
+                    ? 0
+                    : action === "end"
+                        ? last
+                        : current;
+        next.selectedTaskId = tasks[index]?.id ?? null;
+    }
+    else {
+        const rows = effectiveDetailItemCapacity(options.width, options.height, next.density, items.length);
+        const max = Math.max(0, items.length - 1);
+        const current = next.detailScroll[next.detailSection];
+        next.detailScroll[next.detailSection] =
+            action === "up"
+                ? Math.max(0, current - 1)
+                : action === "down"
+                    ? Math.min(max, current + 1)
+                    : action === "home"
+                        ? 0
+                        : action === "end"
+                            ? Math.max(0, items.length - rows)
+                            : current;
+    }
+    next = clampMissionWorkspaceModel(next, snapshot, options);
+    return next;
+}
+function nearestNonEmptyColumn(board, from, direction) {
+    for (let index = columnIndex(from) + direction; index >= 0 && index < MISSION_BOARD_COLUMNS.length; index += direction) {
+        const column = MISSION_BOARD_COLUMNS[index];
+        if (board.columns[column].length > 0)
+            return column;
+    }
+    return null;
+}
+function columnIndex(column) {
+    return MISSION_BOARD_COLUMNS.indexOf(column);
+}
+function missionCardHoverKey(column, index) {
+    return index * MISSION_BOARD_COLUMNS.length + columnIndex(column);
+}
+function missionColumnTitle(column, count, collapsed, width) {
+    if (collapsed)
+        return clipTerminal(`${MISSION_COLUMN_SHORT_LABELS[column]} ${count}`, width);
+    return `${MISSION_COLUMN_LABELS[column]} · ${count}`;
+}
+function missionLaneRect(x, width, height) {
+    return missionLaneViewport(x, MISSION_HEADER_ROWS, width, Math.max(0, height - MISSION_HEADER_ROWS - MISSION_FOOTER_ROWS));
+}
+function missionLaneViewport(x, y, width, height) {
+    const safeWidth = Math.max(0, width);
+    const safeHeight = Math.max(0, height);
+    const bordered = safeWidth >= 2 && safeHeight >= 2;
+    const inset = bordered ? 1 : 0;
+    const innerWidth = Math.max(0, safeWidth - inset * 2);
+    const innerHeight = Math.max(0, safeHeight - inset * 2);
+    const titleRows = innerHeight >= 2 ? 1 : 0;
+    return {
+        x,
+        y,
+        width: safeWidth,
+        height: safeHeight,
+        bodyX: x + inset,
+        bodyY: y + inset + titleRows,
+        bodyWidth: innerWidth,
+        bodyHeight: Math.max(0, innerHeight - titleRows),
+        titleRows,
+    };
+}
+function missionBoardWindow(width, model) {
+    const safeWidth = Math.max(1, width ?? 120);
+    if (model.mode === "board" && model.zoomColumn) {
+        return {
+            offset: columnIndex(model.zoomColumn),
+            columns: [{ column: model.zoomColumn, width: safeWidth, collapsed: false }],
+            hasLeft: false,
+            hasRight: false,
+            maxOffset: columnIndex(model.zoomColumn),
+        };
+    }
+    const maxOffset = missionBoardMaxOffset(safeWidth, model);
+    const offset = Math.min(Math.max(0, model.horizontalOffset), maxOffset);
+    const packed = packMissionBoardColumns(safeWidth, offset, model);
+    const last = packed.at(-1);
+    return {
+        offset,
+        columns: packed,
+        hasLeft: offset > 0,
+        hasRight: last ? columnIndex(last.column) < MISSION_BOARD_COLUMNS.length - 1 : false,
+        maxOffset,
+    };
+}
+function missionBoardMaxOffset(width, model) {
+    for (let offset = 0; offset < MISSION_BOARD_COLUMNS.length; offset++) {
+        const packed = packMissionBoardColumns(width, offset, model);
+        if (packed.some((column) => column.column === "done"))
+            return offset;
+    }
+    return Math.max(0, MISSION_BOARD_COLUMNS.length - 1);
+}
+function packMissionBoardColumns(width, offset, model) {
+    const safeWidth = Math.max(1, width);
+    const columns = [];
+    let used = 0;
+    for (let index = Math.min(Math.max(0, offset), MISSION_BOARD_COLUMNS.length - 1); index < MISSION_BOARD_COLUMNS.length; index++) {
+        const column = MISSION_BOARD_COLUMNS[index];
+        const collapsed = model.collapsedColumns[column] === true;
+        const baseWidth = collapsed ? MISSION_COLLAPSED_COLUMN_WIDTH : MISSION_MIN_COLUMN_WIDTH;
+        const gap = columns.length > 0 ? MISSION_COLUMN_GAP : 0;
+        if (columns.length > 0 && used + gap + baseWidth > safeWidth)
+            break;
+        const widthForColumn = columns.length === 0 ? Math.min(baseWidth, safeWidth) : baseWidth;
+        columns.push({ column, width: widthForColumn, collapsed });
+        used += gap + widthForColumn;
+    }
+    const expanded = columns.filter((column) => !column.collapsed);
+    let remaining = Math.max(0, safeWidth - used);
+    while (remaining > 0 && expanded.some((column) => column.width < MISSION_MAX_COLUMN_WIDTH)) {
+        for (const column of expanded) {
+            if (remaining <= 0)
+                break;
+            if (column.width >= MISSION_MAX_COLUMN_WIDTH)
+                continue;
+            column.width += 1;
+            remaining -= 1;
+        }
+    }
+    return columns.length > 0
+        ? columns
+        : [{ column: MISSION_BOARD_COLUMNS[0], width: safeWidth, collapsed: false }];
+}
+function followColumnOffset(index, offset, width, model) {
+    const maxOffset = missionBoardWindow(width ?? 120, model).maxOffset;
+    let next = Math.min(Math.max(0, offset), maxOffset);
+    if (packMissionBoardColumns(width ?? 120, next, model).some((column) => columnIndex(column.column) === index))
+        return next;
+    if (index < next)
+        return Math.min(index, maxOffset);
+    while (next < maxOffset) {
+        next += 1;
+        if (packMissionBoardColumns(width ?? 120, next, model).some((column) => columnIndex(column.column) === index))
+            return next;
+    }
+    return maxOffset;
+}
+function boardRows(height) {
+    const laneHeight = Math.max(0, (height ?? 24) - MISSION_HEADER_ROWS - MISSION_FOOTER_ROWS);
+    if (laneHeight < 2)
+        return laneHeight;
+    const innerHeight = Math.max(0, laneHeight - 2);
+    const titleRows = innerHeight >= 2 ? 1 : 0;
+    return Math.max(0, innerHeight - titleRows);
+}
+function historyRows(height) {
+    return Math.max(0, (height ?? 24) - MISSION_HEADER_ROWS - MISSION_FOOTER_ROWS);
+}
+function boardItemCapacity(height, density) {
+    const rows = boardRows(height);
+    if (rows <= 0)
+        return 0;
+    return Math.max(1, Math.floor(rows / missionCardHeight(density)));
+}
+function historyItemCapacity(height, density) {
+    return Math.max(0, Math.floor(historyRows(height) / missionHistoryRowHeight(density)));
+}
+function clampTop(top, total, rows) {
+    return Math.max(0, Math.min(Math.max(0, total - Math.max(1, rows)), top));
+}
+function scrollToIndex(index, top, rows) {
+    if (index < top)
+        return index;
+    if (index >= top + rows)
+        return Math.max(0, index - rows + 1);
+    return top;
+}
+function missionCardHeight(density) {
+    if (density === "compact")
+        return 1;
+    if (density === "comfortable")
+        return 3;
+    return 5;
+}
+function missionHistoryRowHeight(density) {
+    if (density === "compact")
+        return 2;
+    if (density === "comfortable")
+        return 4;
+    return 5;
+}
+function missionDetailRowHeight(density) {
+    if (density === "compact")
+        return 2;
+    if (density === "comfortable")
+        return 4;
+    return 5;
+}
+function detailRows(height) {
+    return Math.max(0, (height ?? 24) - MISSION_HEADER_ROWS - 1 - MISSION_FOOTER_ROWS);
+}
+function detailItemCapacity(height, density) {
+    return Math.max(0, Math.floor(detailRows(height) / missionDetailRowHeight(density)));
+}
+function effectiveDetailItemCapacity(width, height, density, itemCount) {
+    if ((width ?? 120) >= 72)
+        return detailItemCapacity(height, density);
+    if (itemCount <= 0)
+        return 0;
+    const availableRows = detailRows(height);
+    const rowHeight = missionDetailRowHeight(density);
+    const reservedContextRows = Math.min(2, availableRows, Math.max(0, availableRows - rowHeight));
+    return Math.max(0, Math.floor((availableRows - reservedContextRows) / rowHeight));
+}
+function missionDetailLayout(width, height, model, detail) {
+    const wide = width >= 72;
+    const contextWidth = wide ? Math.min(34, Math.max(24, Math.floor(width * 0.36))) : 0;
+    const sectionX = wide ? contextWidth + 1 : 0;
+    const sectionWidth = Math.max(1, width - sectionX);
+    const availableRows = detailRows(height);
+    const rawRows = detail
+        ? detailRowsForSection(detail, model.detailSection, model.density, sectionWidth)
+        : [];
+    const itemCapacity = effectiveDetailItemCapacity(width, height, model.density, rawRows.length);
+    const linkLabels = detailLinkLabels(width);
+    const linkWidth = linkLabels.reduce((sum, entry) => sum + terminalDisplayWidth(entry.label), 0) +
+        Math.max(0, linkLabels.length - 1);
+    const linkStart = Math.max(0, width - linkWidth);
+    const sectionLimit = Math.max(0, linkStart - 1);
+    const sectionLabels = MISSION_DETAIL_SECTIONS.map((section, index) => detailSectionLabel(section, index, model.detailSection, width));
+    const sectionSpans = boundedSpansForLabels(sectionLabels, 0, 1, sectionLimit);
+    const sections = sectionLabels
+        .map((label, index) => ({
+        kind: "section",
+        label,
+        section: MISSION_DETAIL_SECTIONS[index],
+        row: 2,
+        start: sectionSpans[index]?.start ?? 0,
+        width: sectionSpans[index]?.width ?? 0,
+    }))
+        .filter((chip) => chip.width > 0 && chip.start + chip.width <= sectionLimit);
+    const linkSpans = boundedSpansForLabels(linkLabels.map((entry) => entry.label), linkStart, 1, width);
+    const links = linkLabels
+        .map((entry, index) => ({
+        kind: "deep-link",
+        label: entry.label,
+        link: entry.link,
+        row: 2,
+        start: linkSpans[index]?.start ?? 0,
+        width: linkSpans[index]?.width ?? 0,
+    }))
+        .filter((chip) => chip.width > 0 && chip.start + chip.width <= width);
+    if (!detail) {
+        return {
+            wide,
+            contextWidth,
+            sectionX,
+            sectionWidth,
+            availableRows,
+            itemCapacity,
+            sections,
+            links,
+            contextRows: [],
+            rows: [],
+        };
+    }
+    const rowHeight = missionDetailRowHeight(model.density);
+    const contextRows = missionDetailContextLines(detail, Math.max(1, contextWidth || width)).map((line, index) => ({
+        kind: "context",
+        id: `context-${index}`,
+        index,
+        hoverKey: index,
+        x: 0,
+        y: MISSION_HEADER_ROWS + 1 + index,
+        width: Math.max(1, contextWidth || width),
+        height: 1,
+        lines: [line],
+    }));
+    const start = Math.max(0, model.detailScroll[model.detailSection]);
+    const maxNarrowContextRows = rawRows.length > 0
+        ? itemCapacity > 0
+            ? Math.max(0, availableRows - rowHeight)
+            : availableRows
+        : availableRows;
+    const narrowContextRows = wide
+        ? []
+        : contextRows.slice(0, Math.min(2, availableRows, maxNarrowContextRows));
+    const capacityAfterContext = itemCapacity;
+    const rows = rawRows.slice(start, start + capacityAfterContext).map((row, visibleIndex) => ({
+        ...row,
+        index: start + visibleIndex,
+        hoverKey: detailHoverKey(model.detailSection, start + visibleIndex),
+        x: sectionX,
+        y: MISSION_HEADER_ROWS + 1 + narrowContextRows.length + visibleIndex * rowHeight,
+        width: sectionWidth,
+        height: rowHeight,
+    }));
+    return {
+        wide,
+        contextWidth,
+        sectionX,
+        sectionWidth,
+        availableRows,
+        itemCapacity,
+        sections,
+        links,
+        contextRows: wide ? contextRows.slice(0, availableRows) : [],
+        rows: [...narrowContextRows, ...rows],
+    };
+}
+function detailSectionLabel(section, index, active, width) {
+    const name = width < 72
+        ? section === "tasks"
+            ? "T"
+            : section === "timeline"
+                ? "L"
+                : section === "attempts"
+                    ? "A"
+                    : "P"
+        : section;
+    return `${index + 1}${width < 72 ? "" : " "}${section === active ? `[${name}]` : name}`;
+}
+function detailLinkLabels(width) {
+    if (width < 36)
+        return [
+            { link: "terminal", label: "t" },
+            { link: "files", label: "f" },
+            { link: "diff", label: "d" },
+        ];
+    if (width < 72)
+        return [
+            { link: "terminal", label: "t term" },
+            { link: "files", label: "f file" },
+            { link: "diff", label: "d diff" },
+        ];
+    return [
+        { link: "terminal", label: "t terminal" },
+        { link: "files", label: "f files" },
+        { link: "diff", label: "d diff" },
+    ];
+}
+function detailRowsForSection(detail, section, density, width) {
+    if (section === "tasks") {
+        return flattenedTasks(detail).map((task) => ({
+            kind: "tasks",
+            id: task.id,
+            lines: missionDetailTaskLines(task, density, width),
+        }));
+    }
+    if (section === "timeline") {
+        return detail.timeline.map((entry) => ({
+            kind: "timeline",
+            id: `${entry.sequence}`,
+            lines: missionDetailTimelineLines(entry, width),
+        }));
+    }
+    if (section === "attempts") {
+        return detail.attempts.map((attempt) => ({
+            kind: "attempts",
+            id: attempt.id,
+            lines: missionDetailAttemptLines(attempt, density, width),
+        }));
+    }
+    return [
+        {
+            kind: "proof",
+            id: "proof",
+            lines: missionDetailProofLines(detail, density, width),
+        },
+    ];
+}
+function detailHoverKey(section, index) {
+    return index * MISSION_DETAIL_SECTIONS.length + MISSION_DETAIL_SECTIONS.indexOf(section);
+}
+function boundedSpansForLabels(labels, start, gap, endExclusive) {
+    let cursor = start;
+    return labels.map((label) => {
+        const width = terminalDisplayWidth(label);
+        if (width <= 0 || cursor + width > endExclusive)
+            return { start: cursor, width: 0 };
+        const span = { start: cursor, width };
+        cursor += width + gap;
+        return span;
+    });
+}
+function missionHeaderLayout(width, model, snapshot, presentation) {
+    const firstRow = [];
+    let cursor = 0;
+    let firstLabel = "";
+    const addFirst = (chip) => {
+        const label = clipTerminal(chip.label, Math.max(0, width - cursor));
+        const chipWidth = terminalDisplayWidth(label);
+        if (chipWidth <= 0 || cursor + chipWidth > width)
+            return null;
+        const placed = { ...chip, label, row: 0, start: cursor, width: chipWidth };
+        firstRow.push(placed);
+        firstLabel = `${firstLabel}${firstLabel ? " " : ""}${label}`;
+        cursor += chipWidth + 1;
+        return placed;
+    };
+    addFirst({
+        kind: "mode",
+        mode: "board",
+        label: missionModeLabel("board", model.mode === "board"),
+    });
+    addFirst({
+        kind: "mode",
+        mode: "history",
+        label: missionModeLabel("history", model.mode === "history"),
+    });
+    addFirst({ kind: "density", label: densityLabel(model.density) });
+    addFirst({ kind: "collapse", label: collapseLabel(model) });
+    addFirst({ kind: "zoom", label: zoomLabel(model) });
+    addFirst({ kind: "refresh", label: "r refresh" });
+    const secondRow = [];
+    const left = "<";
+    const right = ">";
+    if (width >= 1) {
+        secondRow.push({ kind: "horizontal", direction: -1, label: left, row: 1, start: 0, width: 1 });
+    }
+    if (width >= 2) {
+        secondRow.push({
+            kind: "horizontal",
+            direction: 1,
+            label: right,
+            row: 1,
+            start: width - 1,
+            width: 1,
+        });
+    }
+    const secondLabel = missionSecondHeaderLabel(width, model, snapshot, presentation);
+    return { rows: [firstRow, secondRow], labels: [clipTerminal(firstLabel, width), secondLabel] };
+}
+function missionSecondHeaderLabel(width, model, snapshot, presentation) {
+    if (width <= 0)
+        return "";
+    if (width === 1)
+        return "<";
+    const status = missionLoadStatusLabel(presentation);
+    const project = presentation.projectLabel
+        ? ` · ${projectBasename(presentation.projectLabel)}`
+        : "";
+    const summary = snapshot
+        ? `${status}${project} · ${snapshot.board.counts.total} total · ${snapshot.history.length} finished`
+        : `${status}${project}`;
+    const overflow = boardOverflowHint(model, width);
+    if (overflow && width < 30)
+        return `<${fitTerminal(` ${status} · ${overflow} `, width - 2)}>`;
+    return `<${fitTerminal(` ${summary}${overflow ? ` · ${overflow}` : ""} `, Math.max(0, width - 2))}>`;
+}
+function missionFooterLabel(width, model, quitHint) {
+    const quit = quitHint?.trim() || "^q quit";
+    const controls = model.mode === "detail"
+        ? "esc back · tab sections · 1-4 section · arrows move · t/f/d open · r refresh"
+        : `tab mode · arrows move · enter details · z density · c collapse · x ${model.zoomColumn ? "unzoom" : "zoom"} · r refresh`;
+    return fitTerminal(`${quit} · ${controls}`, width);
+}
+function collapseLabel(model) {
+    return model.collapsedColumns[model.selectedColumn] ? "c expand" : "c collapse";
+}
+function zoomLabel(model) {
+    return model.zoomColumn ? "x unzoom" : "x zoom";
+}
+function boardOverflowHint(model, width) {
+    if (model.mode !== "board" || model.zoomColumn)
+        return "";
+    const window = missionBoardWindow(width, model);
+    if (window.hasLeft && window.hasRight)
+        return "more <>";
+    if (window.hasLeft)
+        return "more <";
+    if (window.hasRight)
+        return "more >";
+    return "";
+}
+function fitTerminal(text, width) {
+    if (width <= 0)
+        return "";
+    const clipped = clipTerminal(text, width);
+    return `${clipped}${" ".repeat(Math.max(0, width - terminalDisplayWidth(clipped)))}`;
+}
+function missionLoadStatusLabel(presentation) {
+    if (presentation.loadStatus === "refreshing")
+        return "refreshing";
+    if (presentation.loadStatus === "loading")
+        return "loading";
+    if (presentation.loadStatus === "error")
+        return presentation.errorMessage ?? "error";
+    if (presentation.loadStatus === "empty")
+        return "empty";
+    return "ready";
+}
+function projectBasename(projectLabel) {
+    const trimmed = projectLabel.replace(/[\\/]+$/u, "");
+    const parts = trimmed.split(/[\\/]/u).filter(Boolean);
+    return parts.at(-1) ?? trimmed;
+}
+function missionHeaderHit(header, x, y) {
+    const row = header.rows[y];
+    if (!row)
+        return null;
+    for (const chip of row) {
+        if (x < chip.start || x >= chip.start + chip.width)
+            continue;
+        if (chip.kind === "mode" && chip.mode)
+            return { kind: "mode", mode: chip.mode };
+        if (chip.kind === "density")
+            return { kind: "density" };
+        if (chip.kind === "collapse")
+            return { kind: "collapse" };
+        if (chip.kind === "zoom")
+            return { kind: "zoom" };
+        if (chip.kind === "refresh")
+            return { kind: "refresh" };
+        if (chip.kind === "horizontal" && chip.direction) {
+            return { kind: "horizontal", direction: chip.direction };
+        }
+    }
+    return null;
+}
+function proofSignal(proof) {
+    const parts = [];
+    if (proof.tests.total > 0)
+        parts.push(`tests ${proof.tests.passed}/${proof.tests.total}`);
+    if (proof.diff.filesChanged > 0)
+        parts.push(`diff ${proof.diff.filesChanged}`);
+    if (proof.prs.length > 0)
+        parts.push(`PR ${proof.prs.map((pr) => pr.number ?? pr.status ?? "link").join(",")}`);
+    if (proof.hasProof && parts.length === 0)
+        parts.push(`${proof.proofIds.length} proof`);
+    return parts.length > 0 ? parts.join(" · ") : null;
+}
+function attemptSignals(entry) {
+    const totals = entry.attemptTotals;
+    const parts = [
+        totals.submitted > 0 ? `${totals.submitted} submitted` : "",
+        totals.approved > 0 ? `${totals.approved} approved` : "",
+        totals.rejected > 0 ? `${totals.rejected} rejected` : "",
+        totals.failed > 0 ? `${totals.failed} failed` : "",
+        totals.interrupted > 0 ? `${totals.interrupted} interrupted` : "",
+        totals.running > 0 ? `${totals.running} running` : "",
+    ].filter(Boolean);
+    return parts.length > 0 ? parts.join(", ") : `${totals.total} total`;
+}
+function formatDuration(durationMs) {
+    if (durationMs === null)
+        return "n/a";
+    const seconds = Math.floor(durationMs / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    return `${hours}h ${minutes % 60}m`;
+}