@provos/ironcurtain 0.7.2 → 0.9.0

package/dist/memory/memory-annotations.js

@@ -0,0 +1,87 @@
+/**
+ * Memory MCP server name constant and server configuration builder.
+ *
+ * The memory server is registered as a "trusted server" in the PolicyEngine,
+ * bypassing annotation lookup and policy evaluation entirely. No annotations
+ * or policy rules are needed here.
+ */
+import { createRequire } from 'node:module';
+export const MEMORY_SERVER_NAME = 'memory';
+/**
+ * Resolved path to the memory-mcp-server entry point (computed once).
+ *
+ * Uses Node module resolution so the path works both in development
+ * (workspace symlink) and production (installed from npm).
+ */
+export const MEMORY_SERVER_ENTRY = createRequire(import.meta.url).resolve('@provos/memory-mcp-server');
+/**
+ * Verifies that a server config named 'memory' matches the exact shape
+ * produced by buildMemoryServerConfig(). If the config exists but doesn't
+ * match, the process cannot safely trust it — this is a fatal error.
+ *
+ * Returns true if the config is verified as our memory server,
+ * false if no 'memory' server is configured.
+ * Throws if a 'memory' server exists but has an unexpected shape.
+ */
+export function verifyMemoryServerConfig(mcpServers) {
+    if (!(MEMORY_SERVER_NAME in mcpServers))
+        return false;
+    const config = mcpServers[MEMORY_SERVER_NAME];
+    if (config.command === 'node' && config.args.length === 1 && config.args[0] === MEMORY_SERVER_ENTRY) {
+        return true;
+    }
+    throw new Error(`MCP server "${MEMORY_SERVER_NAME}" has unexpected config ` +
+        `(command=${JSON.stringify(config.command)}, args=${JSON.stringify(config.args)}). ` +
+        `Expected command="node" with args=[${JSON.stringify(MEMORY_SERVER_ENTRY)}]. ` +
+        `The memory server config appears tampered or misconfigured.`);
+}
+/**
+ * Builds the set of trusted server names from the MCP server config.
+ * Currently only the memory server can be trusted, verified by exact
+ * command/args match. Throws if a 'memory' server exists with an
+ * unexpected shape.
+ */
+export function buildTrustedServerSet(mcpServers) {
+    const trusted = new Set();
+    if (verifyMemoryServerConfig(mcpServers)) {
+        trusted.add(MEMORY_SERVER_NAME);
+    }
+    return trusted;
+}
+/**
+ * Builds the MCP server config for the memory server.
+ *
+ * The server runs as a Node.js subprocess using the compiled
+ * memory-mcp-server package entry point. Configuration is passed
+ * via environment variables.
+ */
+export function buildMemoryServerConfig(opts) {
+    const env = {
+        MEMORY_DB_PATH: opts.dbPath,
+    };
+    if (opts.namespace) {
+        env.MEMORY_NAMESPACE = opts.namespace;
+    }
+    // LLM config for summarization, dedup, and compaction.
+    // Falls back to Anthropic API key via their OpenAI-compatible endpoint.
+    if (opts.llmBaseUrl) {
+        env.MEMORY_LLM_BASE_URL = opts.llmBaseUrl;
+    }
+    if (opts.llmApiKey) {
+        env.MEMORY_LLM_API_KEY = opts.llmApiKey;
+    }
+    else if (opts.anthropicApiKey) {
+        env.MEMORY_LLM_API_KEY = opts.anthropicApiKey;
+        if (!opts.llmBaseUrl) {
+            env.MEMORY_LLM_BASE_URL = 'https://api.anthropic.com/v1/';
+        }
+    }
+    return {
+        command: 'node',
+        args: [MEMORY_SERVER_ENTRY],
+        env,
+        description: 'Persistent memory with semantic search',
+        sandbox: false,
+    };
+}
+//# sourceMappingURL=memory-annotations.js.map

package/dist/memory/memory-annotations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-annotations.js","sourceRoot":"","sources":["../../src/memory/memory-annotations.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG5C,MAAM,CAAC,MAAM,kBAAkB,GAAG,QAAQ,CAAC;AAE3C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,2BAA2B,CAAC,CAAC;AAEvG;;;;;;;;GAQG;AACH,MAAM,UAAU,wBAAwB,CAAC,UAA2C;IAClF,IAAI,CAAC,CAAC,kBAAkB,IAAI,UAAU,CAAC;QAAE,OAAO,KAAK,CAAC;IAEtD,MAAM,MAAM,GAAG,UAAU,CAAC,kBAAkB,CAAC,CAAC;IAC9C,IAAI,MAAM,CAAC,OAAO,KAAK,MAAM,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,mBAAmB,EAAE,CAAC;QACpG,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,IAAI,KAAK,CACb,eAAe,kBAAkB,0BAA0B;QACzD,YAAY,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,UAAU,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK;QACpF,sCAAsC,IAAI,CAAC,SAAS,CAAC,mBAAmB,CAAC,KAAK;QAC9E,6DAA6D,CAChE,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAC,UAA2C;IAC/E,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU,CAAC;IAClC,IAAI,wBAAwB,CAAC,UAAU,CAAC,EAAE,CAAC;QACzC,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;IAClC,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CAAC,IAMvC;IACC,MAAM,GAAG,GAA2B;QAClC,cAAc,EAAE,IAAI,CAAC,MAAM;KAC5B,CAAC;IAEF,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;QACnB,GAAG,CAAC,gBAAgB,GAAG,IAAI,CAAC,SAAS,CAAC;IACxC,CAAC;IAED,uDAAuD;IACvD,wEAAwE;IACxE,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;QACpB,GAAG,CAAC,mBAAmB,GAAG,IAAI,CAAC,UAAU,CAAC;IAC5C,CAAC;IACD,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;QACnB,GAAG,CAAC,kBAAkB,GAAG,IAAI,CAAC,SAAS,CAAC;IAC1C,CAAC;SAAM,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;QAChC,GAAG,CAAC,kBAAkB,GAAG,IAAI,CAAC,eAAe,CAAC;QAC9C,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACrB,GAAG,CAAC,mBAAmB,GAAG,+BAA+B,CAAC;QAC5D,CAAC;IACH,CAAC;IAED,OAAO;QACL,OAAO,EAAE,MAAM;QACf,IAAI,EAAE,CAAC,mBAAmB,CAAC;QAC3B,GAAG;QACH,WAAW,EAAE,wCAAwC;QACrD,OAAO,EAAE,KAAK;KACf,CAAC;AACJ,CAAC"}

package/dist/memory/memory-prompt.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Re-exports the memory system prompt builder from the memory MCP server package.
+ *
+ * This thin wrapper centralizes the import so that persona-prompt.ts and
+ * session/index.ts don't need to know the package export path.
+ */
+export { buildMemorySystemPrompt } from '@provos/memory-mcp-server/prompts';
+/**
+ * Rewrites raw MCP tool names (memory_context, memory_store, …) to the
+ * Code Mode namespace-aliased format (memory.context, memory.store, …).
+ */
+export declare function adaptMemoryToolNames(prompt: string): string;

package/dist/memory/memory-prompt.js

@@ -0,0 +1,20 @@
+/**
+ * Re-exports the memory system prompt builder from the memory MCP server package.
+ *
+ * This thin wrapper centralizes the import so that persona-prompt.ts and
+ * session/index.ts don't need to know the package export path.
+ */
+export { buildMemorySystemPrompt } from '@provos/memory-mcp-server/prompts';
+/**
+ * Rewrites raw MCP tool names (memory_context, memory_store, …) to the
+ * Code Mode namespace-aliased format (memory.context, memory.store, …).
+ */
+export function adaptMemoryToolNames(prompt) {
+    return prompt
+        .replaceAll('memory_context', 'memory.context')
+        .replaceAll('memory_store', 'memory.store')
+        .replaceAll('memory_recall', 'memory.recall')
+        .replaceAll('memory_forget', 'memory.forget')
+        .replaceAll('memory_inspect', 'memory.inspect');
+}
+//# sourceMappingURL=memory-prompt.js.map

package/dist/memory/memory-prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-prompt.js","sourceRoot":"","sources":["../../src/memory/memory-prompt.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,uBAAuB,EAAE,MAAM,mCAAmC,CAAC;AAE5E;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAAC,MAAc;IACjD,OAAO,MAAM;SACV,UAAU,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;SAC9C,UAAU,CAAC,cAAc,EAAE,cAAc,CAAC;SAC1C,UAAU,CAAC,eAAe,EAAE,eAAe,CAAC;SAC5C,UAAU,CAAC,eAAe,EAAE,eAAe,CAAC;SAC5C,UAAU,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,CAAC;AACpD,CAAC"}

package/dist/memory/resolve-memory-path.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Resolves the SQLite database path for the memory MCP server
+ * based on the session context (persona or cron job).
+ *
+ * Memory is only available for persona and cron job sessions,
+ * not for ad-hoc default sessions.
+ */
+/**
+ * Returns the absolute path to the memory SQLite database.
+ *
+ * - Persona sessions: ~/.ironcurtain/personas/{name}/memory.db
+ * - Cron jobs (no persona): ~/.ironcurtain/jobs/{jobId}/memory.db
+ *
+ * Uses the established path helpers and validators (createPersonaName,
+ * getJobDir) to ensure consistent validation and path construction.
+ */
+export declare function resolveMemoryDbPath(opts: {
+    persona?: string;
+    jobId?: string;
+}): string;

package/dist/memory/resolve-memory-path.js

@@ -0,0 +1,30 @@
+/**
+ * Resolves the SQLite database path for the memory MCP server
+ * based on the session context (persona or cron job).
+ *
+ * Memory is only available for persona and cron job sessions,
+ * not for ad-hoc default sessions.
+ */
+import { resolve } from 'node:path';
+import { getJobDir } from '../config/paths.js';
+import { getPersonaDir } from '../persona/resolve.js';
+import { createPersonaName } from '../persona/types.js';
+/**
+ * Returns the absolute path to the memory SQLite database.
+ *
+ * - Persona sessions: ~/.ironcurtain/personas/{name}/memory.db
+ * - Cron jobs (no persona): ~/.ironcurtain/jobs/{jobId}/memory.db
+ *
+ * Uses the established path helpers and validators (createPersonaName,
+ * getJobDir) to ensure consistent validation and path construction.
+ */
+export function resolveMemoryDbPath(opts) {
+    if (opts.persona) {
+        return resolve(getPersonaDir(createPersonaName(opts.persona)), 'memory.db');
+    }
+    if (opts.jobId) {
+        return resolve(getJobDir(opts.jobId), 'memory.db');
+    }
+    throw new Error('resolveMemoryDbPath requires either persona or jobId');
+}
+//# sourceMappingURL=resolve-memory-path.js.map

package/dist/memory/resolve-memory-path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-memory-path.js","sourceRoot":"","sources":["../../src/memory/resolve-memory-path.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD;;;;;;;;GAQG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAA0C;IAC5E,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;QACjB,OAAO,OAAO,CAAC,aAAa,CAAC,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC;IAC9E,CAAC;IAED,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;QACf,OAAO,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC,CAAC;IACrD,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;AAC1E,CAAC"}

package/dist/mux/mux-app.d.ts

@@ -17,6 +17,10 @@ export interface MuxAppOptions {
     readonly autoSpawn?: boolean;
     /** Protected paths for workspace validation. */
     readonly protectedPaths?: string[];
+    /** Unique mux instance ID for session ownership. */
+    readonly muxId?: string;
+    /** PID of this mux process (for orphan detection by other mux instances). */
+    readonly muxPid?: number;
 }
 /**
  * Creates and returns a MuxApp.

package/dist/mux/mux-app.js

@@ -12,6 +12,10 @@ import { createMuxRenderer } from './mux-renderer.js';
 import { writeTrustedUserContext } from './trusted-input.js';
 import { createPasteInterceptor } from './paste-interceptor.js';
 import { validateWorkspacePath } from '../session/workspace-validation.js';
+import { scanResumableSessions } from './session-scanner.js';
+import { scanPersonas } from './persona-scanner.js';
+import ora from 'ora';
+import chalk from 'chalk';
 import * as logger from '../logger.js';
 /**
  * Creates and returns a MuxApp.
@@ -49,23 +53,29 @@ export function createMuxApp(options) {
         // If running a compiled JS file or via an installed bin, use it directly
         return { bin: script || 'ironcurtain', prefixArgs: [] };
     }
-    async function spawnSession(workspacePath) {
+    async function spawnSession(opts) {
         const { columns } = process.stdout;
         const ptyRows = renderer.layout.ptyViewportRows;
         const ptyCols = columns || 80;
+        const sessionAgent = opts?.agentOverride ?? agent;
         const { bin, prefixArgs } = resolveIroncurtainBin();
         const bridge = await createPtyBridge({
             cols: ptyCols,
             rows: ptyRows,
             ironcurtainBin: bin,
             prefixArgs,
-            agent,
-            workspacePath,
+            agent: sessionAgent,
+            workspacePath: opts?.workspacePath,
+            resumeSessionId: opts?.resumeSessionId,
+            persona: opts?.persona,
+            muxId: options.muxId,
+            muxPid: options.muxPid,
         });
         const tab = {
             number: nextTabNumber++,
             bridge,
-            label: agent,
+            label: opts?.persona ? `${sessionAgent} (${opts.persona})` : sessionAgent,
+            persona: opts?.persona,
             status: 'running',
             escalationAvailable: false,
             scrollOffset: null,
@@ -96,7 +106,7 @@ export function createMuxApp(options) {
             if (registration && tab.status === 'running') {
                 tab.escalationAvailable = true;
                 escalationManager.addSession(registration);
-                tab.label = registration.label;
+                tab.label = tab.persona ? `${registration.label} [${tab.persona}]` : registration.label;
                 renderer.redrawTabBar();
             }
             else if (!registration) {
@@ -125,7 +135,8 @@ export function createMuxApp(options) {
         }
         tabs.splice(index, 1);
         if (tabs.length === 0) {
-            doShutdown();
+            activeTabIndex = 0;
+            renderer.fullRedraw();
             return;
         }
         if (activeTabIndex >= tabs.length) {
@@ -151,6 +162,27 @@ export function createMuxApp(options) {
         logger.info(message);
         renderer.showMessage(message);
     }
+    function navigateEscalationTab(direction) {
+        const eps = inputHandler.escalationPickerState;
+        if (!eps)
+            return;
+        const sortedNums = escalationManager.sortedDisplayNumbers();
+        if (sortedNums.length === 0)
+            return;
+        const currentIdx = sortedNums.indexOf(eps.focusedDisplayNumber);
+        let newIdx;
+        if (currentIdx === -1) {
+            // Focused escalation was resolved/expired -- snap to first
+            newIdx = 0;
+        }
+        else if (direction === 'next') {
+            newIdx = (currentIdx + 1) % sortedNums.length;
+        }
+        else {
+            newIdx = (currentIdx - 1 + sortedNums.length) % sortedNums.length;
+        }
+        eps.focusedDisplayNumber = sortedNums[newIdx];
+    }
     async function handleAction(action) {
         switch (action.kind) {
             case 'none':
@@ -206,15 +238,16 @@ export function createMuxApp(options) {
                         validatedPath = validateWorkspacePath(action.workspacePath, protectedPaths);
                     }
                     catch (err) {
-                        inputHandler.enterBrowseWithError(action.workspacePath, err instanceof Error ? err.message : String(err));
+                        inputHandler.enterBrowseWithError(action.workspacePath, err instanceof Error ? err.message : String(err), action.persona);
                         renderer.fullRedraw();
                         break;
                     }
                 }
-                const tab = await spawnSession(validatedPath);
+                const tab = await spawnSession({ workspacePath: validatedPath, persona: action.persona });
                 activeTabIndex = tabs.length - 1;
+                const personaPrefix = action.persona ? `persona "${action.persona}" ` : '';
                 const suffix = validatedPath ? ` in ${validatedPath}` : '';
-                showMessage(`Spawned session #${tab.number}${suffix}`);
+                showMessage(`Spawned ${personaPrefix}session #${tab.number}${suffix}`);
                 inputHandler.exitPickerMode();
                 renderer.fullRedraw();
                 break;
@@ -222,9 +255,62 @@ export function createMuxApp(options) {
             case 'picker-cancel':
                 renderer.fullRedraw();
                 break;
+            case 'resume-spawn': {
+                const resumeTab = await spawnSession({
+                    resumeSessionId: action.sessionId,
+                    agentOverride: action.agent,
+                });
+                activeTabIndex = tabs.length - 1;
+                showMessage(`Resuming session ${action.sessionId.substring(0, 8)} as tab #${resumeTab.number}`);
+                renderer.fullRedraw();
+                break;
+            }
+            case 'persona-spawn': {
+                const personaTab = await spawnSession({ persona: action.persona });
+                activeTabIndex = tabs.length - 1;
+                showMessage(`Spawned persona "${action.persona}" as tab #${personaTab.number}`);
+                renderer.fullRedraw();
+                break;
+            }
             case 'redraw-picker':
                 renderer.redrawCommandArea();
                 break;
+            case 'escalation-open': {
+                if (escalationManager.pendingCount === 0) {
+                    showMessage('No pending escalations');
+                    break;
+                }
+                const sortedNums = escalationManager.sortedDisplayNumbers();
+                const previousMode = inputHandler.mode === 'command' ? 'command' : 'pty';
+                inputHandler.enterEscalationPickerMode(sortedNums[0], previousMode);
+                renderer.fullRedraw();
+                break;
+            }
+            case 'escalation-dismiss': {
+                const sortedNums = escalationManager.sortedDisplayNumbers();
+                const highestPending = sortedNums.length > 0 ? sortedNums[sortedNums.length - 1] : 0;
+                inputHandler.dismissEscalationPicker(highestPending, action.targetMode);
+                renderer.fullRedraw();
+                break;
+            }
+            case 'escalation-navigate': {
+                navigateEscalationTab(action.direction);
+                renderer.redrawCommandArea();
+                break;
+            }
+            case 'escalation-resolve': {
+                const message = escalationManager.resolve(action.displayNumber, action.decision, action.whitelist);
+                showMessage(message);
+                // onChange callback (fired synchronously by resolve) handles focus adjustment,
+                // auto-close, and redraws — no additional redraw needed here.
+                break;
+            }
+            case 'escalation-resolve-all': {
+                const message = escalationManager.resolveAll(action.decision, action.whitelist);
+                showMessage(message);
+                // onChange callback handles auto-close and redraws.
+                break;
+            }
             case 'scroll-up':
             case 'scroll-down': {
                 const active = getActiveTab();
@@ -243,8 +329,13 @@ export function createMuxApp(options) {
     function handleCommand(command, args) {
         switch (command) {
             case 'approve':
-            case 'deny': {
-                const decision = command === 'approve' ? 'approved' : 'denied';
+            case 'approve+':
+            case 'deny':
+            case 'deny+': {
+                const baseCommand = command.endsWith('+') ? command.slice(0, -1) : command;
+                // Only approve+ enables whitelisting; deny+ is treated as plain deny.
+                const withWhitelist = command === 'approve+';
+                const decision = baseCommand === 'approve' ? 'approved' : 'denied';
                 const arg = args[0];
                 if (!arg) {
                     showMessage(`Usage: /${command} <number> or /${command} all`);
@@ -252,7 +343,7 @@ export function createMuxApp(options) {
                 }
                 let message;
                 if (arg === 'all') {
-                    message = escalationManager.resolveAll(decision);
+                    message = escalationManager.resolveAll(decision, withWhitelist);
                 }
                 else {
                     const num = parseInt(arg, 10);
@@ -260,7 +351,7 @@ export function createMuxApp(options) {
                         showMessage('Invalid escalation number');
                         break;
                     }
-                    message = escalationManager.resolve(num, decision);
+                    message = escalationManager.resolve(num, decision, withWhitelist);
                 }
                 showMessage(message);
                 renderer.redrawTabBar();
@@ -268,7 +359,48 @@ export function createMuxApp(options) {
                 break;
             }
             case 'new': {
-                inputHandler.enterPickerMode();
+                const personaArg = args[0];
+                if (personaArg) {
+                    // Validate persona before spawning
+                    const personas = scanPersonas();
+                    const match = personas.find((p) => p.name === personaArg);
+                    if (!match) {
+                        showMessage(`Unknown persona: "${personaArg}"`);
+                        break;
+                    }
+                    if (!match.compiled) {
+                        showMessage(`Persona "${personaArg}" is not compiled. Run: ironcurtain persona compile ${personaArg}`);
+                        break;
+                    }
+                    void handleAction({ kind: 'persona-spawn', persona: personaArg });
+                    break;
+                }
+                const personas = scanPersonas();
+                inputHandler.enterPickerMode(personas);
+                renderer.fullRedraw();
+                break;
+            }
+            case 'resume': {
+                const directId = args[0];
+                if (directId) {
+                    // Direct resume by session ID
+                    const sessions = scanResumableSessions();
+                    const match = sessions.find((s) => s.sessionId.startsWith(directId));
+                    if (!match) {
+                        showMessage(`No resumable session matching "${directId}"`);
+                    }
+                    else {
+                        void handleAction({ kind: 'resume-spawn', sessionId: match.sessionId, agent: match.agent });
+                    }
+                    break;
+                }
+                // Open the resume picker
+                const sessions = scanResumableSessions();
+                if (sessions.length === 0) {
+                    showMessage('No resumable sessions found');
+                    break;
+                }
+                inputHandler.enterResumePickerMode(sessions);
                 renderer.fullRedraw();
                 break;
             }
@@ -310,17 +442,15 @@ export function createMuxApp(options) {
                 showMessage(`Unknown command: /${command}`);
         }
     }
+    let resolveShutdown = null;
     function doShutdown() {
         if (!running)
             return;
         running = false;
         pasteInterceptor?.uninstall();
-        for (const tab of tabs) {
-            if (tab.bridge.alive) {
-                tab.bridge.kill();
-            }
-        }
         escalationManager.stop();
+        // Exit fullscreen and destroy renderer before any async work
+        // so the normal terminal is restored immediately.
         if (term) {
             term.grabInput(false);
             term.hideCursor(false);
@@ -328,6 +458,47 @@ export function createMuxApp(options) {
             term.styleReset();
         }
         renderer.destroy();
+        // Collect alive tabs that need to be waited on
+        const aliveTabs = tabs.filter((t) => t.bridge.alive);
+        if (aliveTabs.length === 0) {
+            resolveShutdown?.();
+            return;
+        }
+        // Show a spinner on the real terminal while children shut down
+        const spinner = ora({
+            text: `Shutting down ${aliveTabs.length} PTY session${aliveTabs.length > 1 ? 's' : ''}...`,
+            stream: process.stderr,
+            discardStdin: false,
+        }).start();
+        // Kill all children
+        for (const tab of aliveTabs) {
+            tab.bridge.kill();
+        }
+        // Wait for all children to exit, with a safety timeout
+        let remaining = aliveTabs.length;
+        let settled = false;
+        const settle = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(deadline);
+            spinner.succeed(chalk.dim('All sessions ended'));
+            resolveShutdown?.();
+        };
+        const deadline = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            spinner.warn(chalk.dim(`Timed out waiting for ${remaining} session(s)`));
+            resolveShutdown?.();
+        }, 10_000);
+        for (const tab of aliveTabs) {
+            tab.bridge.onExit(() => {
+                remaining--;
+                if (remaining === 0)
+                    settle();
+            });
+        }
     }
     return {
         async start() {
@@ -347,7 +518,7 @@ export function createMuxApp(options) {
                 void handleAction(action);
             });
             pasteInterceptor.install();
-            escalationManager = createMuxEscalationManager();
+            escalationManager = createMuxEscalationManager({ muxId: options.muxId });
             const { columns, rows } = process.stdout;
             const cols = columns || 80;
             const totalRows = rows || 24;
@@ -361,15 +532,18 @@ export function createMuxApp(options) {
                 getEscalationState: () => escalationManager.state,
                 getPendingCount: () => escalationManager.pendingCount,
                 getPickerState: () => inputHandler.pickerState,
+                getResumePickerState: () => inputHandler.resumePickerState,
+                getPersonaPickerState: () => inputHandler.personaPickerState,
+                getEscalationPickerState: () => inputHandler.escalationPickerState,
                 getScrollOffset: () => {
                     const active = getActiveTab();
                     return active?.scrollOffset ?? null;
                 },
             });
-            term.on('key', (key) => {
+            term.on('key', (key, _matches, data) => {
                 if (!running)
                     return;
-                const action = inputHandler.handleKey(key);
+                const action = inputHandler.handleKey(key, data.code);
                 void handleAction(action);
             });
             // Mouse events come through a separate 'mouse' emitter, not 'key'
@@ -397,6 +571,51 @@ export function createMuxApp(options) {
                 renderer.fullRedraw();
             });
             escalationManager.onChange(() => {
+                const pendingCount = escalationManager.pendingCount;
+                const mode = inputHandler.mode;
+                // Auto-close: picker is open but nothing left
+                if (mode === 'escalation-picker' && pendingCount === 0) {
+                    inputHandler.exitEscalationPickerMode();
+                    renderer.fullRedraw();
+                    return;
+                }
+                // Auto-open: new escalation arrived, picker not already open
+                if (pendingCount > 0 && mode !== 'escalation-picker') {
+                    const sortedNums = escalationManager.sortedDisplayNumbers();
+                    const highestPending = sortedNums[sortedNums.length - 1];
+                    // Only auto-open if the user hasn't dismissed, OR if a genuinely new
+                    // escalation arrived (higher display number than when they dismissed).
+                    const shouldAutoOpen = !inputHandler.escalationDismissed || highestPending > inputHandler.escalationDismissedAtNumber;
+                    if (shouldAutoOpen) {
+                        const previousMode = mode === 'pty' ? 'pty' : mode === 'command' ? 'command' : 'pty'; // if in another picker, treat as pty
+                        // If user is in another picker, cancel it first
+                        if (mode === 'picker') {
+                            inputHandler.exitPickerMode();
+                        }
+                        else if (mode === 'resume-picker') {
+                            inputHandler.exitResumePickerMode();
+                        }
+                        else if (mode === 'persona-picker') {
+                            inputHandler.exitPersonaPickerMode();
+                        }
+                        inputHandler.enterEscalationPickerMode(highestPending, previousMode);
+                        renderer.fullRedraw();
+                        // BEL is already emitted by the escalation manager's onEscalation handler.
+                        return;
+                    }
+                }
+                // Live update while picker is open: re-validate focused tab
+                if (mode === 'escalation-picker') {
+                    const eps = inputHandler.escalationPickerState;
+                    if (eps && !escalationManager.state.pendingEscalations.has(eps.focusedDisplayNumber)) {
+                        // Focused escalation was resolved or expired -- snap to nearest
+                        const sortedNums = escalationManager.sortedDisplayNumbers();
+                        if (sortedNums.length > 0) {
+                            eps.focusedDisplayNumber = sortedNums[0];
+                        }
+                        // If sortedNums is empty, auto-close above will handle it on next tick
+                    }
+                }
                 renderer.redrawTabBar();
                 renderer.redrawCommandArea();
             });
@@ -433,12 +652,11 @@ export function createMuxApp(options) {
             }
             renderer.fullRedraw();
             await new Promise((resolve) => {
-                const checkInterval = setInterval(() => {
-                    if (!running) {
-                        clearInterval(checkInterval);
-                        resolve();
-                    }
-                }, 100);
+                if (!running) {
+                    resolve();
+                    return;
+                }
+                resolveShutdown = resolve;
             });
         },
         // eslint-disable-next-line @typescript-eslint/require-await