tmux-ide 2.7.0 → 2.9.0-beta.5

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.d.ts

@@ -0,0 +1,30 @@
+import type { TuiInputLayer, TuiInputMode, TuiMissionMode } from "./input-lifecycle.ts";
+import type { WorkbenchDockMode, WorkbenchDockTabId, WorkbenchFocusZone } from "./workspace/workbench-shell.ts";
+export interface TuiInteractionContext {
+    dialogOpen: boolean;
+    menuOpen: boolean;
+    paletteOpen: boolean;
+    searchOpen: boolean;
+    surface: TuiInputMode;
+    focusZone: WorkbenchFocusZone;
+    dockMode: WorkbenchDockMode;
+    activeDockTab: WorkbenchDockTabId;
+    missionMode: TuiMissionMode;
+    editorFocus: "list" | "editor";
+    editorFilterOpen: boolean;
+    diffFilterOpen: boolean;
+    homePromptOpen: boolean;
+    hosted: boolean;
+}
+export interface TuiInteractionPresentation {
+    mode: string;
+    focus: string;
+    help: string;
+}
+/** Thin OpenTUI adapter over the renderer-neutral core interaction policy. */
+export declare function tuiInteractionPresentation(context: TuiInteractionContext): TuiInteractionPresentation;
+/** OpenTUI layer names deliberately mirror the core interaction vocabulary. */
+export declare function tuiEscapeFocusTarget(input: {
+    focusZone: WorkbenchFocusZone;
+    layer: TuiInputLayer["kind"];
+}): WorkbenchFocusZone | null;

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.d.ts

@@ -0,0 +1,19 @@
+import type { ProjectRuntimeRepository } from "../../../lib/project-runtime-repository.ts";
+import type { MissionWorkspaceLoadState, MissionWorkspaceSnapshot } from "../missions-workspace.ts";
+/**
+ * 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 declare class MissionWorkspaceLoader {
+    #private;
+    begin(projectKey: string | null, priorSnapshot?: MissionWorkspaceSnapshot | null): MissionWorkspaceLoadState;
+    cancel(): void;
+    accept(generation: number, projectKey: string, snapshot: MissionWorkspaceSnapshot): MissionWorkspaceLoadState | null;
+    reject(generation: number, projectKey: string | null, error: unknown): MissionWorkspaceLoadState | null;
+    isCurrent(generation: number, projectKey: string | null): boolean;
+}
+export declare function readMissionWorkspace(repository: ProjectRuntimeRepository, selectedMissionId?: string | null, now?: () => Date): MissionWorkspaceSnapshot;

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.d.ts

@@ -0,0 +1,89 @@
+/**
+ * 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.
+ */
+/** The surfaces a right-click can target. Each maps to a fixed item list; the
+ *  concrete payload (session name, file path, pane id) rides in the app's menu
+ *  state, not here. */
+export type MenuRegion = "session" | "agent" | "file" | "difffile" | "pane" | "window";
+/** One menu entry. `id` is what the app dispatches on; `danger` items rearm to
+ *  a "confirm: y" state instead of firing immediately; `input` items open an
+ *  inline text line (the string is the prompt) before firing; `children` items
+ *  open a SUBMENU column beside the row (one nesting level); `checkbox` items
+ *  carry a live ✓/✗ state the app supplies (the toggle keeps the menu open). */
+export interface MenuItem {
+    id: string;
+    label: string;
+    danger?: boolean;
+    input?: string;
+    children?: MenuItem[];
+    checkbox?: boolean;
+}
+/** PURE — the fixed item list for each region. The app supplies the context. */
+export declare const MENU_ITEMS: Record<MenuRegion, MenuItem[]>;
+/** 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 declare function paneMenuItems(appMouse: boolean, selectModeOn: boolean, dragDefault: "select" | "forward"): MenuItem[];
+/** 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 declare 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 declare const SUBMENU_CARET = " \u25B8";
+/** 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 declare function menuDims(title: string, items: MenuItem[]): {
+    width: number;
+    height: number;
+};
+/** 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 declare function clampMenuPos(x: number, y: number, width: number, height: number, screenW: number, screenH: number): {
+    left: number;
+    top: number;
+};
+/** The placed overlay's geometry — what the hit-tests need. */
+export interface MenuGeom {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    itemCount: number;
+}
+/** 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 declare function menuItemAt(m: MenuGeom, x: number, y: number): number;
+/** 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 declare function pointInMenu(m: MenuGeom, x: number, y: number): boolean;
+/** 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 declare function submenuPos(parent: MenuGeom, parentItemIndex: number, width: number, height: number, screenW: number, screenH: number): {
+    left: number;
+    top: number;
+};

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.d.ts

@@ -0,0 +1,68 @@
+import type { AgentRowInput } from "./agent-rows.ts";
+import { type MissionWorkspaceHit, type MissionWorkspaceLayout, type MissionWorkspaceModel, type MissionWorkspacePresentationOptions, type MissionWorkspaceSnapshot } from "./missions-workspace.ts";
+export declare const MISSION_DASHBOARD_INSPECTOR_GAP = 1;
+export declare const MISSION_DASHBOARD_COMPACT_INSPECTOR_WIDTH = 24;
+export declare const MISSION_DASHBOARD_WIDE_INSPECTOR_MIN_WIDTH = 34;
+export declare const MISSION_DASHBOARD_WIDE_INSPECTOR_MAX_WIDTH = 46;
+export declare const MISSION_DASHBOARD_MEDIUM_MIN_WIDTH: number;
+export declare const MISSION_DASHBOARD_WIDE_MIN_WIDTH: number;
+export type MissionDashboardVariant = "narrow" | "medium" | "wide";
+export interface MissionDashboardProjection {
+    width: number;
+    height: number;
+    variant: MissionDashboardVariant;
+    main: MissionDashboardRegion;
+    inspector: MissionDashboardInspector | null;
+}
+export interface MissionDashboardRegion {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    layout: MissionWorkspaceLayout;
+}
+export interface MissionDashboardInspector {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    variant: Exclude<MissionDashboardVariant, "narrow">;
+    borderRows: number;
+    titleRows: number;
+    bodyRows: number;
+    title: string;
+    rows: MissionDashboardInspectorRow[];
+    agents: MissionDashboardAgentContext[];
+}
+export interface MissionDashboardInspectorRow {
+    key: string;
+    label: string;
+    value: string;
+    emphasis?: boolean;
+}
+export interface MissionDashboardAgentContext {
+    key: string;
+    rank: "pane" | "session" | "kind";
+    display: string;
+    state: string;
+    context: string;
+}
+export interface MissionDashboardProjectionOptions extends MissionWorkspacePresentationOptions {
+    agents?: readonly AgentRowInput[];
+}
+export declare function missionDashboardProjection(width: number, height: number, model: MissionWorkspaceModel, snapshot: MissionWorkspaceSnapshot | null, options?: MissionDashboardProjectionOptions): MissionDashboardProjection;
+export declare function missionDashboardMainSize(width: number, height: number): {
+    width: number;
+    height: number;
+    mainWidth: number;
+    inspectorWidth: number;
+    variant: MissionDashboardVariant;
+};
+export declare function missionDashboardHitTest(projection: MissionDashboardProjection, x: number, y: number): MissionWorkspaceHit;
+export declare function missionDashboardVariant(width: number): MissionDashboardVariant;
+export declare function missionDashboardInspectorWidth(width: number, variant: MissionDashboardVariant): number;
+export declare function missionDashboardInspectorGeometry(width: number, height: number): {
+    borderRows: number;
+    titleRows: number;
+    bodyRows: number;
+};