tmux-ide 2.8.0 → 2.9.0-beta.14

package/packages/daemon/dist/tui/mirror/input-lifecycle.js

@@ -0,0 +1,147 @@
+export const OPENTUI_KEYMAP_DECISION = {
+    package: "@opentui/keymap",
+    evaluatedVersion: "0.4.3",
+    adopted: false,
+    reason: "The app already has one Solid useKeyboard owner and must forward arbitrary editor/query/pane text; adding keymap here would duplicate rather than replace that root listener.",
+};
+export function resolveInputLayer(context, event, options) {
+    if (event.ctrl && event.name === "q") {
+        return { kind: "lifecycle", command: resolveQuitLifecycleCommand(options, "keyboard") };
+    }
+    if (event.super) {
+        if (event.name === "k" &&
+            !event.ctrl &&
+            !context.dialogOpen &&
+            !context.menuOpen &&
+            !context.paletteOpen &&
+            !context.searchOpen) {
+            return { kind: "kitty-super-palette" };
+        }
+        return { kind: "kitty-super-suppressed" };
+    }
+    if (!event.ctrl && !event.meta && !event.shift && event.name === "f12")
+        return { kind: "global", command: { kind: "toggle-performance-hud" } };
+    if (context.dialogOpen)
+        return { kind: "dialog" };
+    if (context.menuOpen)
+        return { kind: "menu" };
+    if (context.paletteOpen)
+        return { kind: "palette" };
+    if (context.searchOpen)
+        return { kind: "search" };
+    const global = resolveGlobalCommand(context, event);
+    if (global)
+        return { kind: "global", command: global };
+    if (context.mode === "missions") {
+        return context.missionMode === "detail"
+            ? { kind: "missions-detail" }
+            : { kind: "missions-board-history" };
+    }
+    if (context.activePanelInert)
+        return { kind: "inert" };
+    if (event.ctrl && event.name === "e")
+        return { kind: "global", command: { kind: "toggle-editor" } };
+    if (context.mode === "editor") {
+        if (context.editorFocus === "list") {
+            return context.editorFilterOpen ? { kind: "editor-filter" } : { kind: "editor-list" };
+        }
+        return { kind: "editor-input" };
+    }
+    if (context.mode === "diff") {
+        return context.diffFilterOpen ? { kind: "diff-filter" } : { kind: "diff" };
+    }
+    if (context.mode === "home") {
+        return context.homePromptOpen ? { kind: "home-prompt" } : { kind: "home" };
+    }
+    return { kind: "terminal" };
+}
+export function resolveGlobalCommand(context, event) {
+    if (!event.ctrl && !event.meta && !event.shift && event.name === "f12")
+        return { kind: "toggle-performance-hud" };
+    if (context.compositeCycleAvailable &&
+        (event.name === "f8" || (event.ctrl && event.name === "tab"))) {
+        return { kind: "cycle-composite-focus" };
+    }
+    if (event.name === "f5" || (event.ctrl && event.name === "p")) {
+        return { kind: "open-palette" };
+    }
+    if (!event.ctrl &&
+        !event.meta &&
+        !event.shift &&
+        context.configuredShortcutKeys.includes(event.name)) {
+        return { kind: "select-hosted-view", key: event.name };
+    }
+    if (event.ctrl && (event.name === "g" || event.name === "h")) {
+        return { kind: "go-home" };
+    }
+    return null;
+}
+export function resolveQuitLifecycleCommand(options, source) {
+    if (source === "keyboard" && options.hosted)
+        return { kind: "hosted-detach", source };
+    return { kind: "destroy-renderer", source };
+}
+export function resolveCtrlCCommand(context) {
+    if (context.layer === "editor") {
+        return context.hasEditorSelection ? { kind: "copy-editor-selection" } : { kind: "consume" };
+    }
+    if (context.layer === "terminal") {
+        if (!context.mirrorAvailable)
+            return { kind: "consume" };
+        return context.hasTerminalSelection
+            ? { kind: "copy-terminal-selection" }
+            : { kind: "forward-terminal-ctrl-c" };
+    }
+    return { kind: "consume" };
+}
+export function executeCtrlCCommand(command, executor) {
+    if (command.kind === "copy-editor-selection")
+        executor.copyEditorSelection();
+    else if (command.kind === "copy-terminal-selection")
+        executor.copyTerminalSelection();
+    else if (command.kind === "forward-terminal-ctrl-c")
+        executor.forwardTerminalCtrlC();
+}
+export class TuiCleanupRegistry {
+    callbacks = new Map();
+    cleaned = false;
+    set(name, callback) {
+        if (this.cleaned)
+            return;
+        this.callbacks.set(name, callback);
+    }
+    runAll() {
+        if (this.cleaned)
+            return { names: [], failures: [] };
+        this.cleaned = true;
+        const names = [...this.callbacks.keys()];
+        const failures = [];
+        for (const [name, callback] of this.callbacks) {
+            try {
+                callback();
+            }
+            catch (error) {
+                failures.push({ name, error });
+            }
+        }
+        this.callbacks.clear();
+        return { names, failures };
+    }
+}
+export function createTuiLifecycleExecutor(deps) {
+    let destroyRequested = false;
+    return {
+        run(command) {
+            if (command.kind === "destroy-renderer") {
+                if (destroyRequested)
+                    return;
+                destroyRequested = true;
+                deps.destroyRenderer();
+                return;
+            }
+            // Hosted detach belongs to tmux's root key binding, where the invoking
+            // client is still known. A command injected directly into the shared
+            // renderer pane is deliberately consumed without client mutation.
+        },
+    };
+}

package/packages/daemon/dist/tui/mirror/interaction-flow.js

@@ -0,0 +1,41 @@
+import { workspaceEscapeFocusTarget, workspaceInteractionPresentation, } from "@tmux-ide/core";
+/** Thin OpenTUI adapter over the renderer-neutral core interaction policy. */
+export function tuiInteractionPresentation(context) {
+    const overlay = context.dialogOpen
+        ? "dialog"
+        : context.menuOpen
+            ? "menu"
+            : context.paletteOpen
+                ? "commands"
+                : context.searchOpen
+                    ? "search"
+                    : null;
+    const surface = context.surface === "editor"
+        ? "files"
+        : context.surface === "diff"
+            ? "changes"
+            : context.surface === "mirror"
+                ? "terminals"
+                : context.surface;
+    return workspaceInteractionPresentation({
+        overlay,
+        surface: context.focusZone === "dock-body" && context.activeDockTab === "activity"
+            ? "activity"
+            : surface,
+        focusZone: context.focusZone,
+        dockMode: context.dockMode,
+        missionMode: context.missionMode,
+        editorFocus: context.editorFocus,
+        editorFilterOpen: context.editorFilterOpen,
+        diffFilterOpen: context.diffFilterOpen,
+        homePromptOpen: context.homePromptOpen,
+        hosted: context.hosted,
+    });
+}
+/** OpenTUI layer names deliberately mirror the core interaction vocabulary. */
+export function tuiEscapeFocusTarget(input) {
+    return workspaceEscapeFocusTarget({
+        focusZone: input.focusZone,
+        layer: input.layer,
+    });
+}

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

@@ -0,0 +1,84 @@
+import { MissionProjectionError, projectMissionBoard, projectMissionDetail, projectMissionHistory, } from "../../../lib/mission-projections.js";
+import { MissionRepository, MissionRepositoryError } from "../../../lib/mission-repository.js";
+/**
+ * Compatibility loader for the legacy filesystem-backed Missions runtime.
+ *
+ * New presentation and controller code must consume daemon resource
+ * envelopes instead. Keeping this adapter behind an explicit legacy import
+ * prevents MissionRepository and filesystem state from entering the TUI's
+ * eager presentation graph.
+ */
+export class MissionWorkspaceLoader {
+    #generation = 0;
+    #activeProjectKey = null;
+    begin(projectKey, priorSnapshot) {
+        this.#generation += 1;
+        this.#activeProjectKey = projectKey;
+        if (projectKey && priorSnapshot?.project.identityKey === projectKey) {
+            return {
+                status: "refreshing",
+                generation: this.#generation,
+                projectKey,
+                snapshot: priorSnapshot,
+            };
+        }
+        return { status: "loading", generation: this.#generation, projectKey };
+    }
+    cancel() {
+        this.#generation += 1;
+        this.#activeProjectKey = null;
+    }
+    accept(generation, projectKey, snapshot) {
+        if (generation !== this.#generation || projectKey !== this.#activeProjectKey)
+            return null;
+        const status = snapshot.board.counts.total === 0 && snapshot.history.length === 0 ? "empty" : "ready";
+        return { status, generation, snapshot };
+    }
+    reject(generation, projectKey, error) {
+        if (generation !== this.#generation || projectKey !== this.#activeProjectKey)
+            return null;
+        return { status: "error", generation, projectKey, message: missionErrorMessage(error) };
+    }
+    isCurrent(generation, projectKey) {
+        return generation === this.#generation && projectKey === this.#activeProjectKey;
+    }
+}
+export function readMissionWorkspace(repository, selectedMissionId = null, now = () => new Date()) {
+    const missions = new MissionRepository(repository);
+    const { history, state } = missions.snapshot();
+    const board = projectMissionBoard(state, history);
+    const completed = projectMissionHistory(state, history);
+    const detail = selectedMissionId ? projectDetailOrNull(state, history, selectedMissionId) : null;
+    return {
+        board,
+        history: completed.map((entry) => detached(entry)),
+        detail: detail ? detached(detail) : null,
+        project: {
+            identityKey: repository.metadata.identityKey,
+            projectRoot: repository.metadata.projectRoot,
+        },
+        loadedAt: now().toISOString(),
+    };
+}
+function missionErrorMessage(error) {
+    if (error instanceof MissionRepositoryError || error instanceof MissionProjectionError) {
+        return error.message;
+    }
+    if (error instanceof Error)
+        return error.message;
+    return "mission data could not be loaded";
+}
+function projectDetailOrNull(state, history, missionId) {
+    try {
+        return projectMissionDetail(state, history, missionId);
+    }
+    catch (error) {
+        if (error instanceof MissionProjectionError && error.projectionCode === "MISSION_NOT_FOUND") {
+            return null;
+        }
+        throw error;
+    }
+}
+function detached(value) {
+    return JSON.parse(JSON.stringify(value));
+}

package/packages/daemon/dist/tui/mirror/menu-model.js

@@ -0,0 +1,143 @@
+/**
+ * The right-click context-menu model (M19.2) — PURE so it unit-tests without
+ * OpenTUI. app.tsx opens a small overlay at the pointer on a right-button press
+ * (SGR button 2); the ITEM DESCRIPTORS per region and all the geometry (dims,
+ * on-screen clamp, click hit-test) live here, while the closures that actually
+ * attach / kill / split / rename stay in the app (a `run` switch over the
+ * item's `id`).
+ *
+ * The overlay is late-mounted inside a <Show>, so — per the app's mouse
+ * landmine laws — it carries NO per-item handlers: clicks are routed centrally
+ * by coordinate math against {@link menuItemAt}, exactly the way the surface
+ * tab bar and window strip resolve their clicks by x-span math. Keeping that
+ * math in one tested place is the whole point.
+ */
+/** PURE — the fixed item list for each region. The app supplies the context. */
+export const MENU_ITEMS = {
+    session: [
+        { id: "attach", label: "Attach" },
+        { id: "new-agent", label: "New agent…" },
+        { id: "rename", label: "Rename", input: "rename to" },
+        { id: "kill", label: "Kill session", danger: true },
+    ],
+    // Sidebar AGENT rows (M23.1): a left-click jumps; the context menu carries
+    // the lifecycle verbs. "Stop agent" only interrupts (the pane survives);
+    // "Close pane" is the destructive twin that also kills the pane. restart/
+    // stop confirm via DialogConfirm in the app (plain-language body), so only
+    // close — where there is no dialog — uses the inline confirm rearm.
+    agent: [
+        { id: "jump", label: "Go to agent" },
+        { id: "rename", label: "Rename agent", input: "rename to" },
+        { id: "restart", label: "Restart agent" },
+        { id: "stop", label: "Stop agent" },
+        { id: "close", label: "Close pane", danger: true },
+    ],
+    file: [
+        { id: "open", label: "Open" },
+        { id: "newfile", label: "New file", input: "new file" },
+        { id: "rename", label: "Rename", input: "rename to" },
+        { id: "delete", label: "Delete", danger: true },
+    ],
+    difffile: [
+        { id: "open", label: "Open in editor" },
+        { id: "copypath", label: "Copy path" },
+    ],
+    pane: [
+        { id: "split-h", label: "Split horizontal" },
+        { id: "split-v", label: "Split vertical" },
+        { id: "zoom", label: "Zoom toggle" },
+        { id: "swap-next", label: "Swap with next" },
+        { id: "kill", label: "Kill pane", danger: true },
+    ],
+    window: [
+        { id: "new", label: "New window" },
+        { id: "rename", label: "Rename window", input: "rename to" },
+        { id: "kill", label: "Kill window", danger: true },
+    ],
+};
+/** PURE — the pane menu's item list for a concrete pane (M22.9). App-mouse
+ *  panes (the app turned mouse reporting on — presses are forwarded, so a drag
+ *  can't start a selection) get a leading "Select text…" verb that pauses
+ *  forwarding for that pane; while its select mode is active the entry flips to
+ *  the exit verb. They also get the drag-default toggle (M24.2): the label is
+ *  always the OTHER default (`dragDefault` is the pane's current one, override
+ *  and config applied), so picking it flips the pane for the session. Ordinary
+ *  panes keep the fixed list untouched. */
+export function paneMenuItems(appMouse, selectModeOn, dragDefault) {
+    if (!appMouse)
+        return MENU_ITEMS.pane;
+    const entry = selectModeOn
+        ? { id: "select-text-off", label: "Stop selecting" }
+        : { id: "select-text", label: "Select text…" };
+    const dragToggle = dragDefault === "select"
+        ? { id: "drag-forward", label: "Forward mouse drags" }
+        : { id: "drag-select", label: "Select on drag" };
+    return [entry, dragToggle, ...MENU_ITEMS.pane];
+}
+/** The overlay's border (1) + horizontal padding (1 each side). The header row
+ *  and every item row live INSIDE this frame. */
+const BORDER = 1;
+const PAD = 1;
+/** A minimum inner text width so a short menu still reads as a panel. */
+const MIN_INNER = 16;
+/** The suffix a destructive item rearms to (label + this). Reserved in the
+ *  width so "confirm: y" is never clipped — the render appends the SAME string. */
+export const CONFIRM_SUFFIX = "  confirm: y";
+/** The caret a `children` item renders flush-right ("› Layouts        ▸"): a
+ *  leading space + the glyph, reserved in the width so a submenu row's caret is
+ *  never clipped. The base "› " prefix (2) already sits on every row. */
+export const SUBMENU_CARET = " ▸";
+/** PURE — the overlay's cell dimensions for `title` + `items`. Width fits the
+ *  longest of the title and item rows (each item reserves 2 cells for the "› "
+ *  selection prefix); height is the top border + header + items + bottom border.
+ *  Item labels leave slack for the longer "confirm: y" / input renderings, which
+ *  never need to exceed the base width in practice. */
+export function menuDims(title, items) {
+    const inner = Math.max(MIN_INNER, title.length, 
+    // A danger item's rearmed "label  confirm: y" must fit; a `children` item
+    // reserves the "› " prefix AND the flush-right submenu caret; a `checkbox`
+    // item's ✓/✗ mark is the same width as the "› " prefix it replaces. Others
+    // reserve 2 cells for the "› " selection prefix.
+    ...items.map((it) => {
+        if (it.danger)
+            return it.label.length + CONFIRM_SUFFIX.length;
+        if (it.children)
+            return it.label.length + 2 + SUBMENU_CARET.length;
+        return it.label.length + 2;
+    }));
+    return { width: inner + PAD * 2 + BORDER * 2, height: items.length + 3 };
+}
+/** PURE — the on-screen top-left for a menu of `width`×`height` opened at
+ *  (`x`,`y`), clamped so the whole box stays on a `screenW`×`screenH` grid. */
+export function clampMenuPos(x, y, width, height, screenW, screenH) {
+    const left = Math.max(0, Math.min(x, screenW - width));
+    const top = Math.max(0, Math.min(y, screenH - height));
+    return { left, top };
+}
+/** PURE — the item index under (`x`,`y`), or -1 when the point is not on an item
+ *  row (the border, the header, or outside the box). Item `i` renders one row
+ *  below the top border + header, i.e. at screen y = top + 2 + i. */
+export function menuItemAt(m, x, y) {
+    if (x < m.left || x >= m.left + m.width)
+        return -1;
+    const i = y - (m.top + BORDER + 1);
+    return i >= 0 && i < m.itemCount ? i : -1;
+}
+/** PURE — is (`x`,`y`) anywhere inside the overlay box (item, header, or border)?
+ *  A down INSIDE that isn't on an item is a no-op (menu stays); a down OUTSIDE
+ *  closes the menu. */
+export function pointInMenu(m, x, y) {
+    return x >= m.left && x < m.left + m.width && y >= m.top && y < m.top + m.height;
+}
+/** PURE — the on-screen top-left for the SUBMENU column that opens beside the
+ *  `parent` item at `parentItemIndex`. It opens to the RIGHT of the parent, its
+ *  top border aligned with the parent item's row, then clamps fully on-screen
+ *  (sliding left over the parent if the right edge would overflow — acceptable
+ *  since the keyboard/coordinate router owns whichever column is focused). */
+export function submenuPos(parent, parentItemIndex, width, height, screenW, screenH) {
+    const x = parent.left + parent.width;
+    // The parent item renders at y = parent.top + BORDER + header(1) + index; put
+    // the submenu's top border on that same row so the columns read as connected.
+    const y = parent.top + BORDER + 1 + parentItemIndex;
+    return clampMenuPos(x, y, width, height, screenW, screenH);
+}

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

@@ -0,0 +1,261 @@
+import { agentDisplayKind } from "./agent-rows.js";
+import { MISSION_BOARD_COLUMNS, MISSION_COLUMN_GAP, MISSION_MIN_COLUMN_WIDTH, missionWorkspaceHitTest, missionWorkspaceLayout, } from "./missions-workspace.js";
+import { terminalDisplayWidth } from "./panel-host.js";
+import { clipTerminal } from "./terminal-text.js";
+export const MISSION_DASHBOARD_INSPECTOR_GAP = 1;
+export const MISSION_DASHBOARD_COMPACT_INSPECTOR_WIDTH = 24;
+export const MISSION_DASHBOARD_WIDE_INSPECTOR_MIN_WIDTH = 34;
+export const MISSION_DASHBOARD_WIDE_INSPECTOR_MAX_WIDTH = 46;
+export const MISSION_DASHBOARD_MEDIUM_MIN_WIDTH = MISSION_MIN_COLUMN_WIDTH * 3 +
+    MISSION_COLUMN_GAP * 2 +
+    MISSION_DASHBOARD_INSPECTOR_GAP +
+    MISSION_DASHBOARD_COMPACT_INSPECTOR_WIDTH;
+export const MISSION_DASHBOARD_WIDE_MIN_WIDTH = MISSION_MIN_COLUMN_WIDTH * MISSION_BOARD_COLUMNS.length +
+    MISSION_COLUMN_GAP * (MISSION_BOARD_COLUMNS.length - 1) +
+    MISSION_DASHBOARD_INSPECTOR_GAP +
+    MISSION_DASHBOARD_WIDE_INSPECTOR_MIN_WIDTH;
+export function missionDashboardProjection(width, height, model, snapshot, options = {}) {
+    const { width: safeWidth, height: safeHeight, mainWidth, inspectorWidth, variant, } = missionDashboardMainSize(width, height);
+    const mainLayout = missionWorkspaceLayout(mainWidth, safeHeight, model, snapshot, options);
+    const main = {
+        x: 0,
+        y: 0,
+        width: mainWidth,
+        height: safeHeight,
+        layout: mainLayout,
+    };
+    const inspector = inspectorWidth > 0
+        ? missionDashboardInspector(mainWidth + MISSION_DASHBOARD_INSPECTOR_GAP, 0, inspectorWidth, safeHeight, variant === "wide" ? "wide" : "medium", model, snapshot, options.agents ?? [])
+        : null;
+    return { width: safeWidth, height: safeHeight, variant, main, inspector };
+}
+export function missionDashboardMainSize(width, height) {
+    const safeWidth = Math.max(1, width);
+    const safeHeight = Math.max(1, height);
+    const variant = missionDashboardVariant(safeWidth);
+    const inspectorWidth = missionDashboardInspectorWidth(safeWidth, variant);
+    const mainWidth = inspectorWidth > 0
+        ? Math.max(1, safeWidth - MISSION_DASHBOARD_INSPECTOR_GAP - inspectorWidth)
+        : safeWidth;
+    return { width: safeWidth, height: safeHeight, mainWidth, inspectorWidth, variant };
+}
+export function missionDashboardHitTest(projection, x, y) {
+    if (x < projection.main.x ||
+        x >= projection.main.x + projection.main.width ||
+        y < projection.main.y ||
+        y >= projection.main.y + projection.main.height) {
+        return null;
+    }
+    return missionWorkspaceHitTest(projection.main.layout, x - projection.main.x, y - projection.main.y);
+}
+export function missionDashboardVariant(width) {
+    if (width >= MISSION_DASHBOARD_WIDE_MIN_WIDTH)
+        return "wide";
+    if (width >= MISSION_DASHBOARD_MEDIUM_MIN_WIDTH)
+        return "medium";
+    return "narrow";
+}
+export function missionDashboardInspectorWidth(width, variant) {
+    if (variant === "narrow")
+        return 0;
+    if (variant === "medium")
+        return Math.min(MISSION_DASHBOARD_COMPACT_INSPECTOR_WIDTH, width - 1);
+    return Math.max(MISSION_DASHBOARD_WIDE_INSPECTOR_MIN_WIDTH, Math.min(MISSION_DASHBOARD_WIDE_INSPECTOR_MAX_WIDTH, Math.floor(width * 0.24)));
+}
+function missionDashboardInspector(x, y, width, height, variant, model, snapshot, agents) {
+    const selected = selectedMissionContext(model, snapshot);
+    const task = selected.detail ? selectedTaskContext(model, selected.detail) : null;
+    const attempts = selectedAttempts(selected.mission, selected.detail, task);
+    const matchedAgents = relevantMissionAgents(attempts, agents, width - 2);
+    const bodyWidth = Math.max(1, width - 2);
+    const geometry = missionDashboardInspectorGeometry(width, height);
+    const rows = inspectorRows(selected, task, matchedAgents, bodyWidth, variant).slice(0, geometry.bodyRows);
+    const title = selected.mission
+        ? selected.mission.title
+        : snapshot
+            ? "No mission selected"
+            : "Missions";
+    return {
+        x,
+        y,
+        width: Math.max(1, width),
+        height: Math.max(1, height),
+        variant,
+        ...geometry,
+        title: clipTerminal(title, bodyWidth),
+        rows,
+        agents: matchedAgents,
+    };
+}
+export function missionDashboardInspectorGeometry(width, height) {
+    const safeWidth = Math.max(1, width);
+    const safeHeight = Math.max(1, height);
+    const borderRows = safeWidth >= 2 && safeHeight >= 2 ? 2 : 0;
+    const titleRows = safeHeight > borderRows ? 1 : 0;
+    return {
+        borderRows,
+        titleRows,
+        bodyRows: Math.max(0, safeHeight - borderRows - titleRows),
+    };
+}
+function inspectorRows(selected, task, agents, width, variant) {
+    const rows = [];
+    if (!selected.mission) {
+        rows.push(row("state", "state", "select a mission", width, true));
+        rows.push(row("hint", "hint", "board/history selection drives this panel", width));
+        return rows;
+    }
+    const mission = selected.mission;
+    rows.push(row("mission", variant === "wide" ? "mission" : "mis", mission.id, width, true));
+    rows.push(row("status", "status", `${mission.status} · ${progressText(mission)}`, width));
+    if (task) {
+        rows.push(row("task", "task", `${task.id} · ${task.status} · p${task.priority}`, width, true));
+    }
+    else if (selected.detail && selected.detail.taskBoard.counts.total === 0) {
+        rows.push(row("task", "task", "no tasks", width));
+    }
+    else if (selected.detail) {
+        rows.push(row("task", "task", "no task selected", width));
+    }
+    const latest = task?.latestAttempt ?? mission.latestAttempt;
+    if (latest) {
+        rows.push(row("attempt", "attempt", `${latest.status}${latest.agent ? ` · ${latest.agent}` : ""}${latest.model ? ` · ${latest.model}` : ""}`, width));
+        if (latest.session || latest.terminal)
+            rows.push(row("terminal", "term", [latest.session, latest.terminal].filter(Boolean).join(" "), width));
+    }
+    if (agents.length > 0) {
+        rows.push(row("agents", "agents", `${agents.length} relevant`, width, true));
+        for (const agent of agents.slice(0, variant === "wide" ? 4 : 2)) {
+            rows.push(row(`agent-${agent.key}`, agent.state, `${agent.display} · ${agent.context}`, width));
+        }
+    }
+    else {
+        rows.push(row("agents", "agents", "no matching live agent", width));
+    }
+    if (variant === "wide") {
+        if (mission.summary)
+            rows.push(row("summary", "summary", mission.summary, width));
+        if (mission.blockedBy.length > 0)
+            rows.push(row("blocked", "blocked", mission.blockedBy.join(", "), width));
+        if (mission.proofSummary.hasProof)
+            rows.push(row("proof", "proof", `${mission.proofSummary.proofIds.length} item(s)`, width));
+        if (selected.detail && selected.detail.timeline.length > 0) {
+            const last = selected.detail.timeline[selected.detail.timeline.length - 1];
+            rows.push(row("event", "event", `#${last.sequence} ${last.label}`, width));
+        }
+    }
+    return rows;
+}
+function row(key, label, value, width, emphasis = false) {
+    const prefix = `${label}: `;
+    const valueWidth = Math.max(0, width - terminalDisplayWidth(prefix));
+    return {
+        key,
+        label,
+        value: clipTerminal(value, valueWidth),
+        emphasis,
+    };
+}
+function selectedMissionContext(model, snapshot) {
+    if (!snapshot)
+        return { mission: null, detail: null, history: null };
+    const selectedId = model.selectedMissionId;
+    const detail = snapshot.detail && (!selectedId || snapshot.detail.mission.id === selectedId)
+        ? snapshot.detail
+        : null;
+    const boardMission = selectedId ? findMissionCard(snapshot, selectedId) : null;
+    const history = selectedId
+        ? (snapshot.history.find((entry) => entry.mission.id === selectedId) ?? null)
+        : null;
+    return {
+        mission: detail?.mission ?? boardMission ?? history?.mission ?? null,
+        detail,
+        history,
+    };
+}
+function selectedTaskContext(model, detail) {
+    if (!model.selectedTaskId)
+        return null;
+    return (MISSION_BOARD_COLUMNS.flatMap((column) => detail.taskBoard.columns[column]).find((task) => task.id === model.selectedTaskId) ?? null);
+}
+function selectedAttempts(mission, detail, task) {
+    const attempts = new Map();
+    if (task?.latestAttempt)
+        attempts.set(task.latestAttempt.id, task.latestAttempt);
+    if (detail) {
+        for (const attempt of detail.attempts) {
+            if (!task || attempt.taskId === task.id)
+                attempts.set(attempt.id, attempt);
+        }
+    }
+    if (attempts.size === 0 && mission?.latestAttempt) {
+        attempts.set(mission.latestAttempt.id, mission.latestAttempt);
+    }
+    return [...attempts.values()];
+}
+function relevantMissionAgents(attempts, agents, width) {
+    const ranked = new Map();
+    for (const attempt of attempts) {
+        if (attempt.terminal) {
+            for (const agent of agents.filter((item) => item.paneId === attempt.terminal)) {
+                ranked.set(agentKey(agent), agentContext(agent, "pane", width));
+            }
+        }
+    }
+    for (const attempt of attempts) {
+        if (attempt.session) {
+            for (const agent of agents.filter((item) => item.session === attempt.session)) {
+                const key = agentKey(agent);
+                if (!ranked.has(key))
+                    ranked.set(key, agentContext(agent, "session", width));
+            }
+        }
+    }
+    if (ranked.size > 0)
+        return [...ranked.values()];
+    for (const attempt of attempts) {
+        const fallbackKind = attempt.agent;
+        if (!fallbackKind)
+            continue;
+        for (const agent of agents.filter((item) => {
+            const display = agentDisplayKind(item);
+            return item.kind === fallbackKind || display === fallbackKind;
+        })) {
+            const key = agentKey(agent);
+            if (!ranked.has(key))
+                ranked.set(key, agentContext(agent, "kind", width));
+        }
+    }
+    return [...ranked.values()];
+}
+function agentContext(agent, rank, width) {
+    const display = agentDisplayKind(agent);
+    const context = rank === "pane"
+        ? `${agent.session} ${agent.paneId}`
+        : rank === "session"
+            ? `${agent.session} ${agent.paneId}`
+            : `${agent.kind} ${agent.session}`;
+    return {
+        key: agentKey(agent),
+        rank,
+        display: clipTerminal(display, width),
+        state: agent.state,
+        context: clipTerminal(context, width),
+    };
+}
+function agentKey(agent) {
+    return `${agent.session}:${agent.paneId}`;
+}
+function findMissionCard(snapshot, id) {
+    for (const column of MISSION_BOARD_COLUMNS) {
+        const found = snapshot.board.columns[column].find((mission) => mission.id === id);
+        if (found)
+            return found;
+    }
+    return null;
+}
+function progressText(mission) {
+    return mission.progress.total > 0
+        ? `${mission.progress.done}/${mission.progress.total}`
+        : "no tasks";
+}