@aitherium/shell-cli 1.1.0 → 1.11.1

package/dist/completions.js

@@ -297,9 +297,220 @@ export const SUBCOMMAND_DEFS = {
         ['logs', '<service>'],
         ['ps', ''],
     ],
+    // ── Auto-derived from each command's usage string (kept in sync there). ──
+    // These let the generic interactive engine (interactive.ts) prompt for a
+    // subcommand + its arguments when the command is invoked bare. Single-entry
+    // tables whose first element is a placeholder (<x>/[x]/"x") prompt directly
+    // for that positional with no subcommand menu.
+    '/chats': [
+        ['resume', '<id>'],
+        ['delete', '<id>'],
+    ],
+    '/apps': [
+        ['status', '[desktop|node|veil|connect|shell]'],
+        ['install', '<desktop|node|veil|connect|shell>'],
+        ['start', '<desktop|node|veil|connect|shell>'],
+        ['stop', '<desktop|node|veil|connect|shell>'],
+    ],
+    '/gaming': [
+        ['status', ''],
+        ['on', ''],
+        ['off', ''],
+        ['pause', ''],
+    ],
+    '/lockbox': [
+        ['list', ''],
+        ['add', '<name> <content>'],
+        ['add-file', '<name> <path>'],
+        ['remove', '<id>'],
+        ['sync', ''],
+    ],
+    '/soul': [
+        ['list', ''],
+        ['load', '<name>'],
+        ['active', ''],
+    ],
+    '/fleet': [
+        ['status', ''],
+        ['launch', ''],
+        ['drain', '<id>'],
+        ['refresh', '[--build-only] [--recreate-only] [--dry-run]'],
+    ],
+    '/node': [
+        ['ls', ''],
+        ['enroll', '[--tenant <t>] [--ttl <hours>] [--label <l>]'],
+        ['rm', '<id>'],
+    ],
+    '/workflow': [
+        ['list', ''],
+        ['run', '<id>'],
+        ['create', '<yaml_path>'],
+    ],
+    '/benchmark': [
+        ['run', ''],
+        ['history', ''],
+    ],
+    '/review': [
+        ['diff', ''],
+        ['file', '<path>'],
+    ],
+    '/backup': [
+        ['list', ''],
+        ['now', ''],
+    ],
+    '/grid': [
+        ['status', ''],
+        ['add', ''],
+        ['remove', ''],
+        ['test', ''],
+        ['sync', ''],
+        ['pull', ''],
+    ],
+    '/explore': [
+        ['all', '[--free]'],
+        ['agents', '[--free]'],
+        ['tools', '[--free]'],
+        ['skills', '[--free]'],
+        ['grid', '[--free]'],
+    ],
+    '/security': [
+        ['scan', ''],
+        ['status', ''],
+    ],
+    '/train': [
+        ['status', ''],
+        ['start', ''],
+    ],
+    '/demo': [
+        ['start', ''],
+        ['stop', ''],
+        ['status', ''],
+        ['logs', ''],
+    ],
+    '/github': [
+        ['prs', ''],
+        ['issues', ''],
+        ['releases', ''],
+        ['ci', ''],
+        ['merge', '<pr>'],
+    ],
+    '/secrets': [
+        ['list', ''],
+        ['get', '<key>'],
+        ['set', '<key> <value>'],
+        ['delete', '<key>'],
+    ],
+    '/rbac': [
+        ['users', ''],
+        ['roles', ''],
+        ['groups', ''],
+        ['check', '<user> <permission>'],
+    ],
+    '/acc': [
+        ['stats', ''],
+        ['friction', ''],
+        ['unstable', ''],
+        ['node', '<id>'],
+    ],
+    '/sttp': [
+        ['list', ''],
+        ['get', ''],
+        ['calibrate', ''],
+        ['store', '<content>'],
+    ],
+    '/stacks': [
+        ['list', ''],
+        ['status', ''],
+        ['switch', '<name>'],
+    ],
+    '/cloud': [
+        ['models', ''],
+        ['offers', ''],
+        ['active', ''],
+        ['billing', ''],
+        ['deploy', '<model>'],
+        ['status', '[id]'],
+        ['teardown', '<id>'],
+        ['cost', '<model>'],
+    ],
+    '/context': [
+        ['dashboard', ''],
+        ['layers', ''],
+        ['snapshot', ''],
+    ],
+    '/memory': [
+        ['recall', '<query>'],
+        ['remember', '<text>'],
+        ['forget', '<text>'],
+    ],
+    '/models': [
+        ['status', ''],
+        ['list', ''],
+        ['use', '<profile>'],
+        ['set', '<slot> <model>'],
+        ['route', '<tier> <model> [backend]'],
+    ],
+    '/deepseek': [
+        ['status', ''],
+        ['on', ''],
+        ['off', ''],
+        ['test', ''],
+    ],
+    '/pool': [
+        ['status', ''],
+        ['reset', ''],
+    ],
+    '/compute': [
+        ['status', ''],
+        ['discover', ''],
+        ['backends', ''],
+        ['nodes', ''],
+        ['scale', ''],
+    ],
+    '/sandbox': [
+        ['list', ''],
+        ['create', '[name]'],
+        ['stop', '<id>'],
+        ['exec', '<id> <command>'],
+        ['files', '<id>'],
+    ],
+    '/dev': [
+        ['list', ''],
+        ['create', '[name] [lang]'],
+        ['stop', '<id>'],
+        ['codegen', '<id> <prompt>'],
+        ['exec', '<id> <cmd>'],
+        ['task', '<id> <task>'],
+        ['open', '<id>'],
+    ],
+    '/atlas': [
+        ['board', '[--items <N>] [--sync]'],
+        ['tick', '[--items <N>] [--sync]'],
+    ],
+    '/gateway': [
+        ['mint', '<tenant> [scopes] [days]'],
+    ],
+    // Single required/optional positional — prompt directly, no subcommand menu.
+    '/search': [['<query>', '']],
+    '/codegraph': [['<query>', '']],
+    '/think': [['<problem>', '[--effort <7-10>]']],
+    '/deploy': [['<service_name>', '']],
+    '/repowise': [['<question>', '']],
+    '/speak': [['<text>', '[--voice <name>]']],
+    '/ingest': [['<url-or-file>', '[--agent <NAME>] [--workspace <ID>]']],
+    '/inbox': [['[agent_name]', '']],
+    '/approve': [['<username>', '']],
+    '/resume': [['<session_id>', '[prompt]']],
+    '/lyra': [['"<question>"', '[--effort quick_glance|library_session|deep_dive|leave_no_stone]']],
+    '/generate': [['[prompt]', '[--style <style>] [--size <WxH>] [--model <name>]']],
+    '/v4': [['<prompt>', '']],
 };
-// Flat list for tab completion
-export const SUBCOMMANDS = Object.fromEntries(Object.entries(SUBCOMMAND_DEFS).map(([cmd, defs]) => [cmd, defs.map(([name]) => name)]));
+// Flat list for tab completion. Placeholder "names" (<x>, [x], "x") are positional
+// argument prompts for the interactive engine, not real subcommand verbs — drop
+// them here so tab-completion only ever offers actual subcommands.
+export const SUBCOMMANDS = Object.fromEntries(Object.entries(SUBCOMMAND_DEFS)
+    .map(([cmd, defs]) => [cmd, defs.map(([name]) => name).filter(n => !/^["<[]/.test(n))])
+    .filter(([, subs]) => subs.length > 0));
 export function completer(agents) {
     return (line) => {
         // Slash commands
@@ -309,6 +520,29 @@ export function completer(agents) {
             if (spaceIdx > 0) {
                 const cmd = line.slice(0, spaceIdx);
                 const partial = line.slice(spaceIdx + 1);
+                // /imagine value hints — --backend and --model offer their valid values,
+                // and bare "/imagine <Tab>" offers the backends/models subcommands.
+                if (cmd === '/imagine') {
+                    const IMAGE_BACKENDS = ['sana', 'comfyui', 'gemini', 'openai'];
+                    const IMAGE_MODELS = ['sprint', 'quality'];
+                    const mBackend = line.match(/^(.*(?:--backend|-b)\s+)(\S*)$/);
+                    if (mBackend) {
+                        const [, pre, part] = mBackend;
+                        const opts = IMAGE_BACKENDS.filter(b => b.startsWith(part));
+                        return [(opts.length ? opts : IMAGE_BACKENDS).map(b => pre + b), line];
+                    }
+                    const mModel = line.match(/^(.*(?:--model|-m)\s+)(\S*)$/);
+                    if (mModel) {
+                        const [, pre, part] = mModel;
+                        const opts = IMAGE_MODELS.filter(b => b.startsWith(part));
+                        return [(opts.length ? opts : IMAGE_MODELS).map(b => pre + b), line];
+                    }
+                    const subs = ['backends', 'models'];
+                    const hits = subs.filter(s => s.startsWith(partial)).map(s => `${cmd} ${s}`);
+                    if (hits.length)
+                        return [hits, line];
+                    return [[], line];
+                }
                 const subs = SUBCOMMANDS[cmd];
                 if (subs) {
                     const hits = subs

package/dist/config.d.ts

@@ -1,5 +1,16 @@
 import { type AuthUser } from './auth.js';
 export type BackendType = 'genesis' | 'adk' | 'unknown';
+/**
+ * Inference routing mode:
+ *   'auto'    — Genesis /chat/stream when reachable (full agentic pipeline:
+ *               tools, memory, effort), else the gateway's raw /v1/chat/completions.
+ *   'genesis' — always the Genesis-orchestrated pipeline.
+ *   'raw'     — always raw model inference (bypass Genesis; hit the gateway's
+ *               OpenAI-compatible /v1/chat/completions → MicroScheduler/vLLM).
+ *               This is the portable path: works on any endpoint with internet +
+ *               an aither_sk_live_* key, no local Genesis required.
+ */
+export type InferenceMode = 'auto' | 'genesis' | 'raw';
 export interface ShellConfig {
     genesisUrl: string;
     defaultAgent: string;
@@ -7,6 +18,15 @@ export interface ShellConfig {
     historyFile: string;
     model?: string;
     identityUrl: string;
+    /** MCP gateway base URL (mcp.aitherium.com on remote endpoints). */
+    mcpUrl: string;
+    /** Inference routing — Genesis-orchestrated vs raw model (default 'auto'). */
+    inferenceMode: InferenceMode;
+    /** Raw-mode LLM endpoint (the gateway's /v1, or MicroScheduler). Falls back
+     *  to genesisUrl/AITHER_LLM_URL when unset. */
+    llmUrl: string;
+    /** When true, no silent root — a real device-flow login is required. */
+    requireAuth: boolean;
     authToken: string | null;
     authUser: AuthUser | null;
     /** Detected backend type — set after first health probe. */
@@ -19,5 +39,15 @@ export interface ShellConfig {
     privateMode?: boolean;
     /** Base64 data URL image attachments from --image flag. */
     imageAttachments?: string[];
+    /** Resume: session id to continue (set by --continue/--resume/--session). */
+    resumeSessionId?: string;
+    /** True when the session was resumed. */
+    resumed?: boolean;
+    /** Headless print mode (-p/--print): one-shot, scriptable. */
+    printMode?: boolean;
+    /** Headless output format. */
+    outputFormat?: 'text' | 'json' | 'stream-json';
 }
 export declare function loadConfig(): ShellConfig;
+export declare function setActiveConfig(config: ShellConfig): void;
+export declare function getActiveConfig(): ShellConfig | null;

package/dist/config.js

@@ -2,7 +2,7 @@ import { readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { randomUUID } from 'node:crypto';
-import { getActiveToken, getActiveUser, ensureRootProfile } from './auth.js';
+import { getActiveToken, getActiveUser, ensureRootProfile, isRootProvisioningAllowed } from './auth.js';
 export function loadConfig() {
     const home = homedir();
     const configDir = join(home, '.aither');
@@ -19,20 +19,38 @@ export function loadConfig() {
         }
         catch { /* ignore bad config */ }
     }
-    // Load auth from shared ~/.aither/auth.json
-    // If no session exists, auto-provision root (like Linux console login)
+    // Load auth from shared ~/.aither/auth.json.
+    // Normally auto-provision root (like Linux console login). But when
+    // AITHER_REQUIRE_AUTH is set (remote endpoints), do NOT — leave the session
+    // unauthenticated so the shell forces a real device-flow login.
+    const requireAuth = !isRootProvisioningAllowed();
     let authToken = getActiveToken();
-    if (!authToken) {
+    if (!authToken && !requireAuth) {
         ensureRootProfile();
         authToken = getActiveToken();
     }
     const authUser = getActiveUser();
+    // --gateway / AITHER_GATEWAY_URL: one knob to become a portable thin client
+    // pointed at the public gateway for BOTH tools and inference. It defaults the
+    // API/MCP/LLM URLs to the gateway and forces raw inference unless overridden.
+    const gatewayUrl = (process.env.AITHER_GATEWAY_URL || fileConfig.gateway_url || '').replace(/\/+$/, '');
     // AITHER_API_URL is the canonical env var; AITHER_GENESIS_URL is legacy alias
     const apiUrl = process.env.AITHER_API_URL
         || process.env.AITHER_GENESIS_URL
         || fileConfig.api_url
         || fileConfig.genesis_url
+        || gatewayUrl
         || 'http://127.0.0.1:8001';
+    const rawMode = (process.env.AITHER_INFERENCE_MODE || fileConfig.inference_mode || '').toLowerCase();
+    const inferenceMode = rawMode === 'genesis' || rawMode === 'raw' || rawMode === 'auto'
+        ? rawMode
+        : (gatewayUrl ? 'raw' : 'auto');
+    const mcpUrl = process.env.AITHER_MCP_URL
+        || fileConfig.mcp_url
+        || (gatewayUrl ? `${gatewayUrl}/mcp` : '');
+    const llmUrl = process.env.AITHER_LLM_URL
+        || fileConfig.llm_url
+        || (gatewayUrl ? `${gatewayUrl}/v1` : '');
     return {
         genesisUrl: apiUrl,
         defaultAgent: process.env.AITHER_AGENT || fileConfig.default_agent || 'aither',
@@ -40,9 +58,24 @@ export function loadConfig() {
         historyFile: join(configDir, 'shell_history'),
         model: process.env.AITHER_MODEL || fileConfig.model || undefined,
         identityUrl: process.env.AITHER_IDENTITY_URL || fileConfig.identity_url || 'http://127.0.0.1:8115',
+        mcpUrl,
+        inferenceMode,
+        llmUrl,
+        requireAuth,
         authToken,
         authUser,
         backendType: 'unknown',
         backendName: '',
     };
 }
+// ── Active config bridge ──────────────────────────────────────────────────
+// A process-wide reference to the loaded config so deep helpers (e.g. MCP tool
+// invocation in commands.ts) can resolve mcpUrl/authToken without threading
+// `config` through every call site. Set once at REPL/headless startup.
+let _activeConfig = null;
+export function setActiveConfig(config) {
+    _activeConfig = config;
+}
+export function getActiveConfig() {
+    return _activeConfig;
+}

package/dist/crash-reporter.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Automatic Crash & Error Reporter for AitherShell.
+ *
+ * Catches uncaught exceptions and unhandled rejections, prompts the user
+ * to submit an error report, and creates a GitHub issue via Genesis API.
+ *
+ * Flow:
+ *   1. Error caught → format crash report
+ *   2. Prompt user: "Send error report? (Y/n)"
+ *   3. POST to Genesis /feedback → Genesis creates GitHub issue
+ *   4. Show issue URL or fallback support link
+ */
+/** Set the current command context for crash reports. */
+export declare function setCurrentCommand(cmd: string): void;
+/** Mark the TUI active (pass its destroy fn) or inactive (pass null). */
+export declare function setTuiActive(teardown: (() => void) | null): void;
+export declare function installCrashReporter(): void;
+/**
+ * Wrap an async function with crash reporting.
+ * On error, prompts to send report before re-throwing.
+ */
+export declare function withCrashReporting<T>(fn: () => Promise<T>, command?: string): Promise<T>;

package/dist/crash-reporter.js

@@ -0,0 +1,275 @@
+/**
+ * Automatic Crash & Error Reporter for AitherShell.
+ *
+ * Catches uncaught exceptions and unhandled rejections, prompts the user
+ * to submit an error report, and creates a GitHub issue via Genesis API.
+ *
+ * Flow:
+ *   1. Error caught → format crash report
+ *   2. Prompt user: "Send error report? (Y/n)"
+ *   3. POST to Genesis /feedback → Genesis creates GitHub issue
+ *   4. Show issue URL or fallback support link
+ */
+import { createInterface } from 'node:readline';
+import { execSync } from 'node:child_process';
+import { hostname, platform, release, arch, cpus, totalmem } from 'node:os';
+import chalk from 'chalk';
+const GENESIS_URL = process.env.AITHER_GENESIS_URL || 'http://localhost:8001';
+const GITHUB_REPO = 'Aitherium/AitherOS';
+const SUPPORT_URL = 'https://demo.aitherium.com/support';
+const VERSION = '1.10.0'; // keep in sync with package.json
+/** Currently executing command (set by REPL/main before each command). */
+let _currentCommand = '';
+/** Set the current command context for crash reports. */
+export function setCurrentCommand(cmd) {
+    _currentCommand = cmd;
+}
+/**
+ * When the blessed full-screen TUI owns the terminal, the crash reporter must
+ * NOT draw to stdout or prompt on stdin (it would corrupt the screen / steal
+ * keystrokes). The TUI registers a teardown callback here; on a real uncaught
+ * crash we restore the terminal first, then report on the clean terminal.
+ */
+let _tuiTeardown = null;
+/** Mark the TUI active (pass its destroy fn) or inactive (pass null). */
+export function setTuiActive(teardown) {
+    _tuiTeardown = teardown;
+}
+/** Detect GPU (best-effort, non-blocking). */
+function detectGpu() {
+    try {
+        const out = execSync('nvidia-smi --query-gpu=name,memory.total --format=csv,noheader', {
+            timeout: 3000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).toString().trim();
+        return out || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Build a structured crash report from an error. */
+function buildReport(error, source) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    const title = `[AitherShell Crash] ${err.message?.slice(0, 120) || 'Unknown error'}`;
+    return {
+        title,
+        error_type: err.constructor?.name || 'Error',
+        message: err.message || String(error),
+        stack: err.stack || 'No stack trace',
+        context: {
+            command: _currentCommand || undefined,
+            version: VERSION,
+            platform: platform(),
+            arch: arch(),
+            os_release: release(),
+            node_version: process.version,
+            hostname: hostname(),
+            ram_gb: Math.round(totalmem() / (1024 ** 3)),
+            cpu: cpus()[0]?.model || 'unknown',
+            gpu: detectGpu(),
+            timestamp: new Date().toISOString(),
+        },
+    };
+}
+/** Format the crash report as a GitHub issue body (Markdown). */
+function formatIssueBody(report) {
+    const ctx = report.context;
+    return `## Automatic Error Report
+
+**Source**: AitherShell CLI v${ctx.version}
+**Timestamp**: ${ctx.timestamp}
+${ctx.command ? `**Command**: \`${ctx.command}\`` : ''}
+
+### Error
+\`\`\`
+${report.error_type}: ${report.message}
+\`\`\`
+
+### Stack Trace
+\`\`\`
+${report.stack}
+\`\`\`
+
+### Environment
+| Field | Value |
+|-------|-------|
+| Platform | ${ctx.platform} ${ctx.arch} |
+| OS | ${ctx.os_release} |
+| Node | ${ctx.node_version} |
+| RAM | ${ctx.ram_gb} GB |
+| CPU | ${ctx.cpu} |
+${ctx.gpu ? `| GPU | ${ctx.gpu} |` : '| GPU | None detected |'}
+
+---
+*Auto-generated by AitherShell crash reporter*`;
+}
+/** Ask user Y/n with a default of Y. */
+async function askConfirm(prompt) {
+    // If stdin is not a TTY (piped input), default to yes
+    if (!process.stdin.isTTY)
+        return true;
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            rl.close();
+            const a = answer.trim().toLowerCase();
+            resolve(a === '' || a === 'y' || a === 'yes');
+        });
+    });
+}
+/** Submit crash report via Genesis /feedback endpoint. */
+async function submitViaGenesis(report) {
+    try {
+        const resp = await fetch(`${GENESIS_URL}/feedback`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                rating: -1,
+                comment: formatIssueBody(report),
+                category: 'Bug',
+                metadata: {
+                    source: 'aithershell-crash-reporter',
+                    type: 'crash_report',
+                    severity: 'high',
+                    error_type: report.error_type,
+                    title: report.title,
+                    stack_preview: report.stack.split('\n').slice(0, 3).join('\n'),
+                    platform: report.context.platform,
+                    version: report.context.version,
+                    auto_report: true,
+                },
+            }),
+            signal: AbortSignal.timeout(10000),
+        });
+        if (resp.ok) {
+            const data = await resp.json();
+            return data?.feedback_id || 'submitted';
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Try to create a GitHub issue directly via `gh` CLI (fallback). */
+function submitViaGhCli(report) {
+    try {
+        const body = formatIssueBody(report);
+        const result = execSync(`gh issue create --repo ${GITHUB_REPO} --title "${report.title.replace(/"/g, '\\"')}" --label "bug,auto-report" --body -`, {
+            input: body,
+            timeout: 15000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).toString().trim();
+        // gh returns the issue URL
+        return result;
+    }
+    catch {
+        return null;
+    }
+}
+/** Main crash handler — called on uncaught errors. */
+async function handleCrash(error, source) {
+    const report = buildReport(error, source);
+    console.error('');
+    console.error(chalk.red.bold('  AitherShell encountered an error'));
+    console.error(chalk.red(`  ${report.error_type}: ${report.message}`));
+    if (_currentCommand) {
+        console.error(chalk.dim(`  Command: ${_currentCommand}`));
+    }
+    console.error('');
+    const shouldSend = await askConfirm(chalk.yellow('  Send error report to help us fix this? (Y/n) '));
+    if (!shouldSend) {
+        console.error(chalk.dim('  No report sent. You can submit manually at:'));
+        console.error(chalk.cyan(`  ${SUPPORT_URL}`));
+        console.error('');
+        return;
+    }
+    // Try Genesis first, then gh CLI fallback
+    console.error(chalk.dim('  Submitting error report...'));
+    let result = await submitViaGenesis(report);
+    if (result) {
+        console.error(chalk.green(`  Error report submitted (${result}).`));
+        console.error(chalk.dim('  Our team will investigate. Track at:'));
+        console.error(chalk.cyan(`  ${SUPPORT_URL}`));
+    }
+    else {
+        // Fallback: try gh CLI
+        const issueUrl = submitViaGhCli(report);
+        if (issueUrl) {
+            console.error(chalk.green(`  GitHub issue created: ${issueUrl}`));
+        }
+        else {
+            console.error(chalk.yellow('  Could not submit automatically.'));
+            console.error(chalk.dim('  Please report at:'));
+            console.error(chalk.cyan(`  ${SUPPORT_URL}`));
+        }
+    }
+    console.error('');
+}
+/**
+ * Install global error handlers. Call once at startup.
+ *
+ * Catches:
+ * - Uncaught exceptions (synchronous throws)
+ * - Unhandled promise rejections (async throws)
+ */
+/** Benign aborts (request cancelled, AbortSignal.timeout orphans) — never fatal. */
+function isBenignAbort(err) {
+    return err?.name === 'AbortError' || err?.code === 'ABORT_ERR'
+        || err?.name === 'TimeoutError';
+}
+export function installCrashReporter() {
+    process.on('uncaughtException', async (error) => {
+        if (isBenignAbort(error))
+            return; // orphaned fetch/timer abort — ignore
+        // Restore the terminal before drawing the report (no-op outside the TUI).
+        if (_tuiTeardown) {
+            try {
+                _tuiTeardown();
+            }
+            catch { /* */ }
+            _tuiTeardown = null;
+        }
+        await handleCrash(error, 'uncaughtException');
+        process.exit(1);
+    });
+    // Unhandled rejections must NOT tear the process down. In the blessed TUI a
+    // stray async rejection during a long turn (e.g. an orphaned AbortSignal.timeout
+    // surfacing in the silent gap of a grounded follow-up) would otherwise hit
+    // process.exit(1) and kill the whole session mid-render. Report-but-survive.
+    process.on('unhandledRejection', async (reason) => {
+        const error = reason instanceof Error ? reason : new Error(String(reason));
+        if (isBenignAbort(error))
+            return;
+        // While the TUI owns the terminal, never draw/prompt over it — submit the
+        // report silently and keep the session alive.
+        if (_tuiTeardown) {
+            try {
+                await submitViaGenesis(buildReport(error, 'unhandledRejection'));
+            }
+            catch { /* */ }
+            return;
+        }
+        try {
+            await handleCrash(error, 'unhandledRejection');
+        }
+        catch { /* */ }
+        // Intentionally do NOT process.exit — keep the session alive.
+    });
+}
+/**
+ * Wrap an async function with crash reporting.
+ * On error, prompts to send report before re-throwing.
+ */
+export async function withCrashReporting(fn, command) {
+    if (command)
+        setCurrentCommand(command);
+    try {
+        return await fn();
+    }
+    catch (error) {
+        await handleCrash(error, 'command');
+        throw error;
+    }
+}