@aria-cli/cli 1.0.57 → 1.0.59

package/dist/ink-repl.js

@@ -1,4183 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useState, useCallback, useEffect, useRef, useMemo } from "react";
-import { render, useApp } from "ink";
-import { REPL } from "./ui/screens/REPL.js";
-import { useTerminalSize } from "./ui/hooks/useTerminalSize.js";
-import { pickRandomVerbPair } from "./ui/verb-pairs.js";
-import * as sounds from "./sounds.js";
-import { COMMANDS } from "./commands/definitions.js";
-import { Banner, } from "./ui/components/index.js";
-import { CLI_VERSION, WHATS_NEW } from "./release-notes.js";
-import { autonomyToConfirmation, AUTONOMY_LEVELS, DEFAULT_SAFETY_CONFIG, isPrivateLanIP, } from "@aria-cli/aria";
-import { mergeDiscoveredPeersByIdentity } from "./peer-identity.js";
-import { deriveDisplayOverrides, nextDisplayMode, resolveDisplayConfig, } from "./ui/display-mode.js";
-import { setTheme, getTheme, getAvailableThemes, getThemeDefinition } from "./ui/theme/index.js";
-import { parseMessage, recoverCrashedSessions, NoopOTELAdapter, HttpOTELAdapter, JsonlEventLogger, } from "@aria-cli/aria";
-import { resolveTrustedRuntimeErrorMessage, } from "@aria-cli/tools";
-import { getCliModels, getCliSelectableModels, getDefaultModelByTier, getModelByShortName, MODEL_REGISTRY, selectRunnableModelVariant, toShortName, } from "@aria-cli/models";
-import { MemoriaPool } from "@aria-cli/aria";
-import { getErrorMessage, log } from "@aria-cli/types";
-import { repairToolCallPairing, fromModelMessages, toModelMessages, createUserMessage, createSystemMessage, createErrorMessage, createIncomingMessagePair, TurnAccumulator, findJsonlForSession, mergeWithJsonlRecovery, } from "./history/index.js";
-import { SessionHistoryClient } from "./history/SessionHistoryClient.js";
-import { loadConfig, saveConfig } from "./config.js";
-import { DEFAULT_EVENT_LOOP_WATCHDOG_THRESHOLD_MS, startEventLoopWatchdog, getStallPhase, setStallPhase, clearStallPhase, } from "./event-loop-watchdog.js";
-import { getPendingResumeSessionId, setPendingResumeSessionId, setPendingArionName, writeRelaunchMarker, } from "./relaunch.js";
-import { loadAriaDisplayConfig } from "./config/index.js";
-import { randomUUID } from "crypto";
-import { parseSlashCommand } from "./slash-commands.js";
-import { HeadlessKernel } from "./headless/kernel.js";
-import { createHeadlessCapabilityServices } from "./headless/kernel-services.js";
-import { runTerminalSetup, isTerminalSetupSupported } from "./commands/terminal-setup.js";
-import { LocalControlManager } from "./local-control-manager.js";
-import { useUnifiedMessages } from "./ui/hooks/useUnifiedMessages.js";
-/** Detect ARIA_SESSION_EXPIRED errors thrown by withReattach after exhausting retries. */
-function isSessionExpiredError(err) {
-    return (err != null &&
-        typeof err === "object" &&
-        "code" in err &&
-        err.code === "ARIA_SESSION_EXPIRED");
-}
-function formatApprovalInput(input) {
-    try {
-        const raw = typeof input === "string" ? input : JSON.stringify(input);
-        if (!raw)
-            return "";
-        return raw.length > 160 ? `${raw.slice(0, 160)}...` : raw;
-    }
-    catch {
-        return "";
-    }
-}
-function hasDirectClientInboxControl(localControl) {
-    return (!!localControl &&
-        "listDirectClientInbox" in localControl &&
-        typeof localControl.listDirectClientInbox ===
-            "function");
-}
-function logEventLoopStallToStderr(stallMs) {
-    const phase = getStallPhase();
-    const phaseInfo = phase
-        ? `phase="${phase.label}" (active for ${phase.ageMs.toFixed(0)}ms)`
-        : "phase=unknown (no phase set)";
-    const message = `[InkREPL][WARN] Event loop stall detected: ${stallMs.toFixed(0)}ms ` +
-        `(threshold ${DEFAULT_EVENT_LOOP_WATCHDOG_THRESHOLD_MS}ms) ${phaseInfo}\n`;
-    const stack = new Error("[InkREPL] Event loop watchdog detection stack").stack ?? "[stack unavailable]";
-    try {
-        process.stderr.write(message);
-        process.stderr.write(`${stack}\n`);
-    }
-    catch {
-        // Best effort only: the watchdog must never crash the TUI while reporting.
-    }
-}
-function logSystemSleepToStderr(sleepMs) {
-    if (!process.env.DEBUG)
-        return;
-    try {
-        const secs = (sleepMs / 1000).toFixed(1);
-        process.stderr.write(`[InkREPL][DEBUG] System sleep/suspend detected: ${secs}s\n`);
-    }
-    catch {
-        // Best effort only.
-    }
-}
-function toApprovalRiskLevel(riskLevel) {
-    if (riskLevel === "high" || riskLevel === "dangerous") {
-        return "high";
-    }
-    if (riskLevel === "moderate") {
-        return "moderate";
-    }
-    return "low";
-}
-function resolvePausedToolApprovalRequest(state, pendingApproval) {
-    if (pendingApproval) {
-        return pendingApproval;
-    }
-    const pendingTool = state.pendingToolCalls[0];
-    if (!pendingTool) {
-        return null;
-    }
-    const extraPendingCount = Math.max(state.pendingToolCalls.length - 1, 0);
-    return {
-        toolName: extraPendingCount > 0 ? `${pendingTool.name} (+${extraPendingCount} more)` : pendingTool.name,
-        input: pendingTool.arguments,
-        riskLevel: toApprovalRiskLevel(typeof pendingTool.estimatedRisk === "string"
-            ? pendingTool.estimatedRisk
-            : pendingTool.riskLevel),
-    };
-}
-function extractLatestAssistantText(messages) {
-    for (let i = messages.length - 1; i >= 0; i--) {
-        if (messages[i]?.role === "assistant") {
-            return messages[i].content;
-        }
-    }
-    return "";
-}
-function toProviderQualifiedModelValue(model) {
-    return `${model.provider}/${model.shortName}`;
-}
-function resolveModelFromCommandArg(modelArg, availableModels, credentialHints) {
-    const normalized = modelArg.trim().toLowerCase();
-    if (!normalized)
-        return undefined;
-    const sorted = [...availableModels].sort((a, b) => a.shortName.localeCompare(b.shortName));
-    // 0. Exact provider-qualified match (e.g., github-copilot/gpt-4.1)
-    const byQualifiedExact = sorted.find((m) => {
-        const qualified = `${m.provider}/${m.shortName}`.toLowerCase();
-        return qualified === normalized;
-    });
-    if (byQualifiedExact)
-        return byQualifiedExact;
-    // 1. Exact shortName match
-    const exact = sorted.find((m) => m.shortName.toLowerCase() === normalized);
-    if (exact)
-        return selectRunnableModelVariant(exact, credentialHints);
-    // 2. Prefix shortName match
-    const byPrefix = sorted.find((m) => m.shortName.toLowerCase().startsWith(normalized));
-    if (byPrefix)
-        return selectRunnableModelVariant(byPrefix, credentialHints);
-    // 2b. Prefix provider-qualified match
-    const byQualifiedPrefix = sorted.find((m) => {
-        const qualified = `${m.provider}/${m.shortName}`.toLowerCase();
-        return qualified.startsWith(normalized);
-    });
-    if (byQualifiedPrefix)
-        return byQualifiedPrefix;
-    // 3. Tier match
-    const byTier = sorted.find((m) => m.tier.toLowerCase() === normalized);
-    if (byTier)
-        return selectRunnableModelVariant(byTier, credentialHints);
-    // 4. Display name contains query
-    const byDisplay = sorted.find((m) => m.displayName.toLowerCase().includes(normalized));
-    if (byDisplay)
-        return selectRunnableModelVariant(byDisplay, credentialHints);
-    // 5. Provider contains query
-    const byProvider = sorted.find((m) => m.provider.toLowerCase().includes(normalized));
-    return byProvider ? selectRunnableModelVariant(byProvider, credentialHints) : undefined;
-}
-// Execute tools preserving original order; read-only contiguous runs are parallelized.
-export async function executeToolCallsInOrder(toolCalls, registry, executeSingleTool) {
-    const toolResults = new Array(toolCalls.length);
-    let readOnlyBatch = [];
-    const flushReadOnlyBatch = async () => {
-        if (readOnlyBatch.length === 0)
-            return;
-        const settled = await Promise.allSettled(readOnlyBatch.map((b) => executeSingleTool(b.call)));
-        const results = settled.map((s, i) => s.status === "fulfilled"
-            ? s.value
-            : {
-                id: readOnlyBatch[i].call.id,
-                result: `Tool error: ${s.reason?.message || "Unknown error"}`,
-                isError: true,
-            });
-        for (let i = 0; i < readOnlyBatch.length; i++) {
-            toolResults[readOnlyBatch[i].index] = results[i];
-        }
-        readOnlyBatch = [];
-    };
-    for (let i = 0; i < toolCalls.length; i++) {
-        const tc = toolCalls[i];
-        const tool = registry.get(tc.name);
-        if (tool?.isReadOnly) {
-            readOnlyBatch.push({ index: i, call: tc });
-        }
-        else {
-            await flushReadOnlyBatch();
-            toolResults[i] = await executeSingleTool(tc);
-        }
-    }
-    await flushReadOnlyBatch();
-    return toolResults;
-}
-/**
- * Module-level shutdown state — populated by InkRepl component, consumed by
- * startInkRepl after waitUntilExit(). This bridges the React component
- * lifecycle with the outer async function that owns process exit.
- */
-const _shutdownState = {
-    sessionId: null,
-    sessionHistory: null,
-    memoriaSession: null,
-    memoriaFactory: null,
-    jsonlLogger: null,
-};
-function formatAskUserResumePrompt(question, index, total) {
-    const header = total > 1
-        ? `Run paused: answer question ${index + 1} of ${total} to continue.`
-        : "Run paused: answer the question below to continue.";
-    const options = Array.isArray(question.options) && question.options.length > 0
-        ? `\nOptions: ${question.options.join(" | ")}`
-        : "";
-    return `${header}\n${question.question}${options}`;
-}
-function InkRepl({ session, manager, router, aria, localControlManager, cliContext, sessionHistory, initialModel = "sonnet-4.5", inputHistory = [], onSaveInput, initialMessage, resumeSessionId, cachedUserName, initialAvailableModels = getCliModels(), refreshAvailableModels, credentialHints, authResolver, }) {
-    const { exit } = useApp();
-    // Unified message state — single array + streaming cursor replaces the old
-    // dual messages/previewMessages pattern that had race conditions on paired setState calls.
-    const { committedItems: messages, streamingItems: previewMessages, isStreaming: unifiedIsStreaming, dispatch: msgDispatch, setItems: setMessages, } = useUnifiedMessages();
-    const config = loadConfig();
-    const preferredTier = config.preferredTier || "balanced";
-    const preferredModel = getDefaultModelByTier(preferredTier, credentialHints);
-    const resolvedModel = preferredModel?.shortName || initialModel;
-    const [model, setModel] = useState(resolvedModel);
-    const modelRef = useRef(resolvedModel);
-    const [effortLevel, setEffortLevel] = useState(config.effortLevel ?? "high");
-    const isStreaming = unifiedIsStreaming;
-    const isStreamingRef = useRef(false);
-    // When true, the next appendUserConversationInput skips setMessages (display already handled).
-    const skipNextUserDisplayRef = useRef(false);
-    const initialMessageFired = useRef(false);
-    const resumeSessionFired = useRef(false);
-    const resumeRestoreReadyRef = useRef(Promise.resolve());
-    const queuedMessageRef = useRef(null);
-    const [queuedMessage, setQueuedMessage] = useState(null);
-    const [responseTime, setResponseTime] = useState();
-    const [arions, setArions] = useState([]);
-    const [userName, setUserName] = useState(cachedUserName ?? null);
-    const [memoryCount, setMemoryCount] = useState(0);
-    const [memories, setMemories] = useState([]);
-    const [memoryBrowserMode, setMemoryBrowserMode] = useState("browse");
-    const [isLoadingMemories, setIsLoadingMemories] = useState(false);
-    const [sessions, setSessions] = useState([]);
-    const [availableModels, setAvailableModels] = useState(initialAvailableModels);
-    useEffect(() => {
-        const control = localControlManager.getControl();
-        if (!control)
-            return;
-        let active = true;
-        void control
-            .getModelSnapshot?.()
-            .then((snapshot) => {
-            if (!active)
-                return;
-            setAvailableModels(snapshot.models);
-            if (snapshot.currentModel) {
-                setModel(snapshot.currentModel);
-                modelRef.current = snapshot.currentModel;
-            }
-        })
-            .catch(() => {
-            // Keep initial snapshot if daemon model catalog is unavailable.
-        });
-        return () => {
-            active = false;
-        };
-    }, [localControlManager]);
-    const [openSessionOverlaySignal, setOpenSessionOverlaySignal] = useState(undefined);
-    const [openThemeOverlaySignal, setOpenThemeOverlaySignal] = useState(undefined);
-    const [openSoundOverlaySignal, setOpenSoundOverlaySignal] = useState(undefined);
-    const [openDaemonOverlaySignal, setOpenDaemonOverlaySignal] = useState(undefined);
-    const [daemonStatus, setDaemonStatus] = useState({ running: false });
-    const [daemonActionStatus, setDaemonActionStatus] = useState(null);
-    const [connectionState, setConnectionState] = useState("connected");
-    // Startup grace: suppress transport churn in the StatusBar before the first
-    // stable connection so the user never sees a flash of "⚡ offline" on boot.
-    const bootGraceUntilRef = useRef(Date.now() + 15_000);
-    const sawStableConnectedRef = useRef(false);
-    // Unsub handle for the current client's state listener.
-    const connectionStateUnsubRef = useRef(null);
-    const sessionPageRef = useRef(0);
-    const sessionSearchQueryRef = useRef("");
-    const sessionSearchSeqRef = useRef(0);
-    const sessionSearchDebounceRef = useRef(null);
-    const SESSION_PAGE_SIZE = 100;
-    // Autonomy level — ref for closure stability (onApprovalNeeded reads it), state for re-renders.
-    // Both are always updated together via setAutonomyLevel helper below.
-    const initialAutonomy = config.autonomy ?? DEFAULT_SAFETY_CONFIG.autonomy;
-    const autonomyLevelRef = useRef(initialAutonomy);
-    const [autonomyLevelState, setAutonomyLevelState] = useState(initialAutonomy);
-    /** Update autonomy level — keeps ref + state in sync, persists to config */
-    const setAutonomyLevel = useCallback((level) => {
-        autonomyLevelRef.current = level;
-        setAutonomyLevelState(level);
-        saveConfig({ ...loadConfig(), autonomy: level });
-    }, []);
-    // Whether to show the interactive AutonomySelector panel
-    const [showAutonomySelector, setShowAutonomySelector] = useState(false);
-    // Login provider picker and OAuth flow state
-    const [loginPickerProviders, setLoginPickerProviders] = useState(null);
-    const [copilotSourceOptions, setCopilotSourceOptions] = useState(null);
-    const [oauthProvider, setOAuthProvider] = useState(null);
-    const [oauthAuthorizeUrl, setOAuthAuthorizeUrl] = useState(null);
-    const [oauthExpectedState, setOAuthExpectedState] = useState(null);
-    const [oauthFieldKey, setOAuthFieldKey] = useState(null);
-    const [copilotDeviceProvider, setCopilotDeviceProvider] = useState(null);
-    const [copilotDeviceProfileLabel, setCopilotDeviceProfileLabel] = useState(null);
-    const [copilotDeviceVerificationUri, setCopilotDeviceVerificationUri] = useState(null);
-    const [copilotDeviceUserCode, setCopilotDeviceUserCode] = useState(null);
-    // Anthropic method picker, key input, and setup-token input state
-    const [anthropicMethodOptions, setAnthropicMethodOptions] = useState(null);
-    const [anthropicKeyInputVisible, setAnthropicKeyInputVisible] = useState(false);
-    const [anthropicSetupTokenVisible, setAnthropicSetupTokenVisible] = useState(false);
-    // OpenAI method picker and key input state
-    const [openaiMethodOptions, setOpenAIMethodOptions] = useState(null);
-    const [openaiKeyInputVisible, setOpenAIKeyInputVisible] = useState(false);
-    // Google method picker and key input state
-    const [googleMethodOptions, setGoogleMethodOptions] = useState(null);
-    const [googleKeyInputVisible, setGoogleKeyInputVisible] = useState(false);
-    const [pendingAuthInteraction, setPendingAuthInteraction] = useState(null);
-    const [authInteractionOptions, setAuthInteractionOptions] = useState(null);
-    const [authInteractionTitle, setAuthInteractionTitle] = useState(null);
-    const [authInteractionInput, setAuthInteractionInput] = useState(null);
-    // Peer discovery state
-    const [nearbyPeers, setNearbyPeers] = useState([]);
-    const [localClients, setLocalClients] = useState([]);
-    const [openPeersOverlaySignal, setOpenPeersOverlaySignal] = useState(undefined);
-    const [openClientsOverlaySignal, setOpenClientsOverlaySignal] = useState(undefined);
-    // InviteShareOverlay and JoinInviteOverlay are rendered by App from these props.
-    const [inviteShare, setInviteShare] = useState(null);
-    const [openJoinInviteOverlaySignal, setOpenJoinInviteOverlaySignal] = useState(undefined);
-    const [joinInviteError, setJoinInviteError] = useState(null);
-    const [incomingPairRequest, setIncomingPairRequest] = useState(null);
-    const pairPollRef = useRef(null);
-    // Tool approval dialog state — each request gets a unique ID so React
-    // remounts the PermissionPrompt when back-to-back approvals arrive
-    // without an intermediate null (React batching).
-    const approvalIdRef = useRef(0);
-    const [approvalRequest, setApprovalRequest] = useState(null);
-    useEffect(() => {
-        modelRef.current = model;
-    }, [model]);
-    useEffect(() => {
-        activeArionRef.current = session.getPrimary()?.name || config.activeArion || "ARIA";
-    }, [session, config.activeArion]);
-    const [pendingAskUserResume, setPendingAskUserResume] = useState(null);
-    const requestToolApproval = useCallback((request) => new Promise((resolve) => {
-        approvalIdRef.current += 1;
-        setApprovalRequest({
-            id: approvalIdRef.current,
-            toolName: request.toolName,
-            input: request.input,
-            riskLevel: request.riskLevel,
-            ...(request.issues ? { issues: request.issues } : {}),
-            resolve,
-        });
-    }), []);
-    const appendSessionHistoryText = useCallback((message) => {
-        session.addToHistory(message);
-    }, [session]);
-    const appendUserConversationInput = useCallback((input) => {
-        const userConvMsg = createUserMessage(input);
-        if (sessionHistory && sessionIdRef.current) {
-            sessionHistory.persistMessagesNonBlocking(sessionIdRef.current, [userConvMsg]);
-        }
-        _shutdownState.jsonlLogger?.log({
-            type: "user_message",
-            content: input,
-            id: userConvMsg.id,
-        });
-        // Skip display append if already rendered (e.g. incoming agent message).
-        if (skipNextUserDisplayRef.current) {
-            skipNextUserDisplayRef.current = false;
-        }
-        else {
-            setMessages((prev) => [...prev, userConvMsg]);
-        }
-        appendSessionHistoryText({ role: "user", content: input });
-    }, [appendSessionHistoryText, sessionHistory]);
-    const logInternalRunFailure = useCallback((error) => {
-        const diagnostic = error && typeof error === "object" && "diagnostic" in error
-            ? error.diagnostic
-            : undefined;
-        _shutdownState.jsonlLogger?.log({
-            type: "error",
-            error: {
-                message: resolveTrustedRuntimeErrorMessage(getErrorMessage(error), diagnostic) ??
-                    getErrorMessage(error),
-                ...(diagnostic === undefined ? {} : { diagnostic }),
-            },
-        });
-    }, []);
-    const appendAssistantConversationHistory = useCallback((messages, arion) => {
-        const content = extractLatestAssistantText(messages).trim();
-        if (!content) {
-            return;
-        }
-        appendSessionHistoryText({
-            role: "assistant",
-            content,
-            ...(arion ? { arion } : {}),
-        });
-    }, [appendSessionHistoryText]);
-    // Observability metrics for the StatusBar
-    const [metrics, setMetrics] = useState({
-        turnCount: 0,
-        totalTokens: 0,
-        estimatedCost: 0,
-        wallTimeSeconds: 0,
-        contextTokens: 0,
-        contextStale: false,
-    });
-    // Unread mesh message count for StatusBar indicator
-    const [meshMessageCount, setMeshMessageCount] = useState(0);
-    // Runtime socket path for real-time peer message subscription.
-    // Resolved asynchronously to avoid blocking the render thread with a
-    // synchronous require("@aria-cli/server") (the full server module graph).
-    const [runtimeSocket, setRuntimeSocket] = useState(null);
-    useEffect(() => {
-        let cancelled = false;
-        (async () => {
-            try {
-                const socket = await localControlManager.resolveRuntimeSocket();
-                if (!cancelled)
-                    setRuntimeSocket(socket);
-            }
-            catch {
-                // Non-critical — runtimeSocket is optional.
-            }
-        })();
-        return () => {
-            cancelled = true;
-        };
-    }, [localControlManager]);
-    // Display mode state — initialized from ~/.aria/config.yaml (4-layer merge: preset -> file)
-    const [ariaDisplayConfig] = useState(() => {
-        const cfg = loadAriaDisplayConfig();
-        // Theme: single source of truth is config.json (/theme command writes here).
-        // On first run, migrate from config.yaml so existing manual edits are honored once.
-        const jsonConfig = loadConfig();
-        let themeName = jsonConfig.theme;
-        if (!themeName && cfg.display.theme) {
-            // One-time migration: YAML → JSON. After this, config.json owns theme.
-            themeName = cfg.display.theme;
-            try {
-                saveConfig({ ...jsonConfig, theme: themeName });
-            }
-            catch (e) {
-                log.warn("[Theme] YAML→JSON migration failed (non-fatal):", e.message);
-            }
-        }
-        if (themeName) {
-            const validThemes = getAvailableThemes();
-            if (validThemes.includes(themeName)) {
-                setTheme(themeName);
-            }
-            else {
-                log.warn(`[Theme] Invalid theme "${themeName}" in config, using default`);
-            }
-        }
-        return cfg;
-    });
-    const otelAdapterRef = useRef(ariaDisplayConfig.persistence.otelEndpoint
-        ? new HttpOTELAdapter(ariaDisplayConfig.persistence.otelEndpoint)
-        : new NoopOTELAdapter());
-    const [displayMode, setDisplayMode] = useState(ariaDisplayConfig.display.mode);
-    const [displayConfig, setDisplayConfig] = useState(() => {
-        const { mode: _, syntaxHighlighting: _sh, maxToolOutputLines: _mt, maxThinkingPreview: _mp, ...dc } = ariaDisplayConfig.display;
-        return dc;
-    });
-    const [pipelineTiming, setPipelineTiming] = useState(undefined);
-    // Trace spans for TraceWaterfall visualization
-    const [spans, setSpans] = useState([]);
-    // Force remount of App's <Static> renderer when replacing transcript wholesale
-    // (e.g. /resume, /clear). Ink <Static> is append-only and keeps internal
-    // render cursor state; remounting avoids "resume works once" behavior.
-    const [staticRenderEpoch, setStaticRenderEpoch] = useState(0);
-    // Active arion name for the current run (displayed in StatusBar)
-    const [activeArion, setActiveArion] = useState();
-    const activeArionRef = useRef(session.getPrimary()?.name || config.activeArion || "ARIA");
-    // ObservabilityContext for the current run — passed to App for the indicator state machine hook
-    const [obsCtx, setObsCtx] = useState(null);
-    const runStartTimeRef = useRef(0);
-    const wallTimeSecondsRef = useRef(0);
-    const wallTimeIntervalRef = useRef(null);
-    const abortController = useRef(null);
-    useEffect(() => {
-        // Init sound from config (default: on)
-        const soundConfig = loadConfig().soundEnabled;
-        sounds.setEnabled(soundConfig !== false);
-        sounds.onSessionStart();
-        return () => {
-            sounds.onSessionEnd();
-        };
-    }, []);
-    useEffect(() => {
-        return startEventLoopWatchdog({
-            thresholdMs: DEFAULT_EVENT_LOOP_WATCHDOG_THRESHOLD_MS,
-            onStall: logEventLoopStallToStderr,
-            onSleep: logSystemSleepToStderr,
-        });
-    }, []);
-    // Accumulated conversation messages across turns. Updated from RunResult.messages
-    // (via messages_snapshot events) after each runner invocation completes.
-    const sessionMessagesRef = useRef([]);
-    // SQLite session ID — created lazily on first submit
-    const sessionIdRef = useRef(null);
-    // Concrete Memoria ref for session lifecycle (endSession on cleanup)
-    const memoriaSessionRef = useRef(null);
-    // Shared MemoriaFactory via MemoriaPool — replaces inline caching.
-    const memoriaFactoryRef = useRef(null);
-    if (!memoriaFactoryRef.current) {
-        const ariaDir = process.env.ARIA_HOME ?? `${process.env.HOME}/.aria`;
-        const pool = new MemoriaPool(ariaDir, router, () => sessionIdRef.current);
-        memoriaFactoryRef.current = pool.toFactory();
-    }
-    // Cleanup MemoriaPool on unmount: end Memoria session, then flush WAL connections
-    useEffect(() => {
-        return () => {
-            const sessionId = sessionIdRef.current;
-            const cleanup = async () => {
-                if (sessionId && sessionHistory) {
-                    try {
-                        sessionHistory.markCompleted(sessionId);
-                    }
-                    catch (err) {
-                        log.warn("[InkREPL] SessionHistory completion mark failed:", err);
-                    }
-                }
-                // End the Memoria session so the sessions table records ended_at and memory_count
-                if (sessionId && memoriaSessionRef.current) {
-                    try {
-                        await memoriaSessionRef.current.endSession(sessionId);
-                    }
-                    catch (err) {
-                        log.warn("[InkREPL] Memoria session end failed (non-critical):", err);
-                    }
-                }
-                // Flush SQLite WAL connections
-                await memoriaFactoryRef.current?.closeAll();
-            };
-            cleanup().catch((err) => {
-                log.warn("[InkREPL] MemoriaPool cleanup failed:", err?.message);
-            });
-        };
-    }, []);
-    // ── Local runtime control ───────────────────────────────────────────────
-    // The TUI is a pure local client. It never owns networking primitives
-    // directly and never starts an embedded server through a CLI-local path.
-    const localControlManagerRef = useRef(null);
-    // Synchronous bootstrap: HeadlessKernel is constructed during render via
-    // useMemo, so the shared LocalControlManager must already exist before then.
-    if (!localControlManagerRef.current) {
-        localControlManagerRef.current = localControlManager;
-    }
-    const waitForLocalControlReady = useCallback(async (signal) => {
-        const deadline = Date.now() + 20_000;
-        while (Date.now() < deadline) {
-            if (signal?.aborted) {
-                return null;
-            }
-            const control = localControlManagerRef.current?.getControl() ?? null;
-            if (control) {
-                return control;
-            }
-            await new Promise((resolve) => setTimeout(resolve, 250));
-        }
-        return localControlManagerRef.current?.getControl() ?? null;
-    }, []);
-    const getLocalControlClient = useCallback(async () => {
-        return (await waitForLocalControlReady()) ?? null;
-    }, [waitForLocalControlReady]);
-    const getLocalControlClientSync = useCallback(() => {
-        return localControlManagerRef.current?.getControl() ?? null;
-    }, []);
-    // Bind the shared manager and write agent-bridge.json for external agents.
-    useEffect(() => {
-        localControlManagerRef.current = localControlManager;
-        const attached = localControlManager.getAttached();
-        if (attached) {
-            log.debug(`[InkREPL] Bound shared local-control manager to runtime ${attached.runtimeId} on port ${attached.port} (${attached.ownership}, node ${attached.nodeId})`);
-        }
-        void (async () => {
-            try {
-                const bridgeDir = `${process.env.ARIA_HOME ?? `${process.env.HOME}/.aria`}/run`;
-                const bridgePath = `${bridgeDir}/agent-bridge.json`;
-                const tmpPath = `${bridgePath}.${process.pid}.tmp`;
-                const fs = require("fs");
-                const socketPath = runtimeSocket ?? (await localControlManager.resolveRuntimeSocket());
-                fs.mkdirSync(bridgeDir, { recursive: true });
-                fs.writeFileSync(tmpPath, JSON.stringify({
-                    socketPath,
-                    clientId: attached?.attachedClientId ?? null,
-                    nodeId: attached?.nodeId ?? null,
-                    pid: process.pid,
-                    updatedAt: new Date().toISOString(),
-                }, null, 2));
-                fs.renameSync(tmpPath, bridgePath);
-                log.debug(`[InkREPL] Wrote agent-bridge.json (clientId=${attached?.attachedClientId ?? "n/a"}, socket=${socketPath})`);
-            }
-            catch (err) {
-                log.debug(`[InkREPL] Failed to write agent-bridge.json: ${err instanceof Error ? err.message : String(err)}`);
-            }
-        })();
-        return () => {
-            localControlManagerRef.current = null;
-        };
-    }, [localControlManager, runtimeSocket]);
-    const headlessRunKernel = useMemo(() => {
-        if (!sessionHistory || !cliContext) {
-            return null;
-        }
-        const memoriaProxy = new Proxy({}, {
-            get(_target, prop) {
-                return async (...args) => {
-                    const primary = session.getPrimary();
-                    const currentMemoria = primary && typeof session.getArionMemoria === "function"
-                        ? await session.getArionMemoria(primary)
-                        : null;
-                    const memoria = currentMemoria ?? aria.components.memoria;
-                    const memoriaRecord = memoria;
-                    const method = memoriaRecord[prop];
-                    if (typeof method !== "function") {
-                        throw new Error(`Memoria method ${String(prop)} is unavailable`);
-                    }
-                    return method.apply(memoria, args);
-                };
-            },
-        });
-        const localControlProxy = localControlManagerRef.current.getControl();
-        return new HeadlessKernel({
-            cli: cliContext,
-            localControl: localControlProxy,
-            sessionLedger: sessionHistory,
-            resolveRuntimeSocket: () => localControlManager.resolveRuntimeSocket(),
-            ...createHeadlessCapabilityServices({
-                cli: cliContext,
-                activeArionName: session.getPrimary()?.name ?? cliContext.config.activeArion ?? "ARIA",
-                overrides: {
-                    memoria: memoriaProxy,
-                    arionManager: {
-                        list: () => manager.list(),
-                        hatch: (input) => manager.hatch(input),
-                        get: async (name) => {
-                            const arions = await manager.list();
-                            return (arions.find((arion) => arion.name.toLowerCase() === name.toLowerCase()) ?? null);
-                        },
-                        wake: (name) => manager.wake(name),
-                        rest: (name) => session.dismiss(name),
-                    },
-                    config: {
-                        async getTheme() {
-                            return getTheme();
-                        },
-                        async setTheme(theme) {
-                            const validThemes = getAvailableThemes();
-                            if (!validThemes.includes(theme)) {
-                                throw new Error(`Unknown theme: ${theme}`);
-                            }
-                            setTheme(theme);
-                            const config = loadConfig();
-                            config.theme = theme;
-                            saveConfig(config);
-                            return { theme };
-                        },
-                        async getAutonomy() {
-                            return autonomyLevelRef.current;
-                        },
-                        async setAutonomy(autonomy) {
-                            if (!AUTONOMY_LEVELS.includes(autonomy)) {
-                                throw new Error(`Invalid autonomy level: ${autonomy}`);
-                            }
-                            setAutonomyLevel(autonomy);
-                            return { autonomy };
-                        },
-                        async getActiveArion() {
-                            return (activeArionRef.current ??
-                                session.getPrimary()?.name ??
-                                cliContext.config.activeArion);
-                        },
-                        async setActiveArion(name) {
-                            activeArionRef.current = name;
-                            const config = loadConfig();
-                            config.activeArion = name;
-                            saveConfig(config);
-                        },
-                    },
-                    modelDiscovery: {
-                        async listAvailable() {
-                            return availableModels;
-                        },
-                        async refresh() {
-                            return availableModels;
-                        },
-                        async getCurrentModel() {
-                            return model;
-                        },
-                        async setCurrentModel(nextModel) {
-                            const normalized = nextModel.trim();
-                            if (!normalized) {
-                                throw new Error("Model name is required");
-                            }
-                            setModel(normalized);
-                            modelRef.current = normalized;
-                            const primary = session.getPrimary();
-                            if (primary) {
-                                await manager.setPreferredModel(primary.name, normalized);
-                            }
-                            return {
-                                currentModel: normalized,
-                            };
-                        },
-                    },
-                },
-            }),
-            system: {
-                async restart(input) {
-                    const reason = typeof input.reason === "string" &&
-                        input.reason.trim().length > 0
-                        ? input.reason.trim()
-                        : "Restart requested";
-                    return { accepted: true, reason };
-                },
-                async terminalSetup() {
-                    if (!isTerminalSetupSupported()) {
-                        return {
-                            supported: false,
-                            message: "terminal-setup is supported only in iTerm2 (macOS) and VSCode terminal.",
-                        };
-                    }
-                    return {
-                        supported: true,
-                        output: runTerminalSetup().trim(),
-                    };
-                },
-            },
-        });
-    }, [
-        aria,
-        availableModels,
-        cliContext,
-        manager,
-        model,
-        session,
-        sessionHistory,
-        setAutonomyLevel,
-    ]);
-    // Connection state is shown live in the StatusBar — no system messages needed.
-    useEffect(() => {
-        if (!headlessRunKernel)
-            return;
-        connectionStateUnsubRef.current?.();
-        connectionStateUnsubRef.current = null;
-        setConnectionState(headlessRunKernel.getConnectionState());
-        connectionStateUnsubRef.current = headlessRunKernel.onConnectionStateChange((nextState) => {
-            const inBootGrace = Date.now() < bootGraceUntilRef.current;
-            if (inBootGrace && !sawStableConnectedRef.current && nextState !== "connected") {
-                // Suppress startup transport churn before first stable connection.
-                return;
-            }
-            if (nextState === "connected") {
-                sawStableConnectedRef.current = true;
-            }
-            setConnectionState(nextState);
-        });
-        return () => {
-            connectionStateUnsubRef.current?.();
-            connectionStateUnsubRef.current = null;
-        };
-    }, [headlessRunKernel]);
-    const dispatchHeadlessCommand = useCallback(async (op, input) => {
-        if (!headlessRunKernel) {
-            throw new Error(`Headless kernel unavailable for ${op}`);
-        }
-        let interactionFrame = null;
-        let resultFrame = null;
-        for await (const frame of headlessRunKernel.dispatch({
-            kind: "request",
-            requestId: `${op}:${randomUUID()}`,
-            op,
-            input,
-        })) {
-            if (frame.kind === "interaction.required") {
-                interactionFrame = frame;
-            }
-            else if (frame.kind === "result") {
-                resultFrame = frame;
-            }
-        }
-        return {
-            interactionFrame,
-            resultFrame,
-        };
-    }, [headlessRunKernel]);
-    useEffect(() => {
-        let cancelled = false;
-        const refreshUnreadMeshCount = async () => {
-            try {
-                // Query the client inbox (client-targeted messages) + node inbox
-                // (broadcasts) via the direct-client endpoint for a complete count.
-                const clientInbox = await dispatchHeadlessCommand("client.inbox.list", {
-                    limit: 100,
-                    unreadOnly: true,
-                }).catch(() => null);
-                const fallbackInbox = clientInbox
-                    ? null
-                    : await dispatchHeadlessCommand("message.inbox.list", {
-                        limit: 100,
-                        unreadOnly: true,
-                    });
-                const inbox = clientInbox ?? fallbackInbox;
-                const unread = inbox?.resultFrame?.ok &&
-                    Array.isArray(inbox.resultFrame.result.events)
-                    ? inbox.resultFrame.result.events
-                    : [];
-                const unreadCount = unread.length;
-                if (!cancelled) {
-                    setMeshMessageCount(unreadCount);
-                }
-            }
-            catch (err) {
-                // Best-effort only — unread count refresh must never break the REPL.
-                if (isSessionExpiredError(err)) {
-                    cancelled = true;
-                    clearInterval(unreadPollInterval);
-                    return;
-                }
-                if (!cancelled) {
-                    setMeshMessageCount(0);
-                }
-            }
-        };
-        void refreshUnreadMeshCount();
-        const unreadPollInterval = setInterval(() => {
-            if (!cancelled)
-                void refreshUnreadMeshCount();
-        }, 3_000);
-        return () => {
-            cancelled = true;
-            clearInterval(unreadPollInterval);
-        };
-    }, [dispatchHeadlessCommand]);
-    // Real-time push: subscribe to incoming messages and inject into the agent loop.
-    // Dedup: suppress identical messages from the same sender within a 30s window
-    // to avoid flooding the REPL (e.g. detached CLI agents sending repeated status updates).
-    useEffect(() => {
-        let cancelled = false;
-        const control = headlessRunKernel;
-        if (!control?.subscribeDirectClientInbox)
-            return;
-        const activeAttached = localControlManagerRef.current?.getAttached();
-        const localNodeId = activeAttached?.nodeId;
-        const localClientId = activeAttached?.attachedClientId;
-        // Track recent messages for content-based dedup: "sender\0content" → { timestamp, count }
-        const recentMessages = new Map();
-        const DEDUP_WINDOW_MS = 30_000;
-        const run = async () => {
-            // Retry loop: reconnect the subscription after daemon restarts.
-            while (!cancelled) {
-                try {
-                    const stream = control.subscribeDirectClientInbox({
-                        afterCreatedAt: Date.now(),
-                    });
-                    for await (const event of stream) {
-                        if (cancelled)
-                            break;
-                        // Skip messages from remote peers on this node.
-                        if (event.senderNodeId === localNodeId)
-                            continue;
-                        // Skip self-sent messages (e.g. replies to arion land in node
-                        // inbox and are visible to all same-node clients). With PID-stable
-                        // clientIds, senderClientId reliably identifies the originating client.
-                        if (event.senderClientId && localClientId && event.senderClientId === localClientId)
-                            continue;
-                        // Skip messages addressed to a different client on this node.
-                        if (event.recipientClientId &&
-                            localClientId &&
-                            event.recipientClientId !== localClientId)
-                            continue;
-                        // Content-based dedup: skip identical messages from the same sender within window.
-                        const dedupKey = `${event.senderNodeId}\0${event.content}`;
-                        const now = Date.now();
-                        const existing = recentMessages.get(dedupKey);
-                        if (existing && now - existing.ts < DEDUP_WINDOW_MS) {
-                            existing.count++;
-                            existing.ts = now;
-                            continue; // suppress duplicate
-                        }
-                        recentMessages.set(dedupKey, { ts: now, count: 1 });
-                        // Evict stale entries to prevent unbounded growth.
-                        if (recentMessages.size > 200) {
-                            for (const [key, entry] of recentMessages) {
-                                if (now - entry.ts >= DEDUP_WINDOW_MS)
-                                    recentMessages.delete(key);
-                            }
-                        }
-                        const baseName = event.senderDisplayNameSnapshot?.trim() || event.senderNodeId || "Unknown";
-                        // Include PID from senderClientId (e.g. "client-pid-12345") to
-                        // distinguish multiple ARIA instances in the UI.
-                        const senderPid = event.senderClientId?.match(/^client-pid-(\d+)$/)?.[1];
-                        const senderName = senderPid ? `${baseName} (pid ${senderPid})` : baseName;
-                        const content = typeof event.content === "string" ? event.content : JSON.stringify(event.content);
-                        // The reply address: prefer display name (send_message accepts @name),
-                        // fall back to nodeId for remote peers.
-                        const senderAddress = senderName !== "Unknown" ? senderName : event.senderNodeId || "unknown";
-                        // Synthesize a check_messages tool call + result pair.
-                        // The LLM sees this as "I checked my inbox and got a message" —
-                        // the most natural prompt to reply via send_message.
-                        const [syntheticCall, syntheticResult] = createIncomingMessagePair(senderName, senderAddress, content, event.id);
-                        // Inject the synthetic tool pair into conversation + display.
-                        // toRenderItems detects synthetic_inbox_ IDs and renders as incoming-message.
-                        if (sessionHistory && sessionIdRef.current) {
-                            sessionHistory.persistMessagesNonBlocking(sessionIdRef.current, [
-                                syntheticCall,
-                                syntheticResult,
-                            ]);
-                        }
-                        setMessages((prev) => [...prev, syntheticCall, syntheticResult]);
-                        if (!isStreamingRef.current) {
-                            // Idle: trigger a new agent turn. Include the full message so the
-                            // LLM has everything it needs — no reason to call check_messages.
-                            skipNextUserDisplayRef.current = true;
-                            handleSubmitRef.current(`[Incoming message from "${senderName}" (${senderAddress})]\n\n${content}\n\n[Reply using send_message with to="${senderAddress}"]`);
-                        }
-                        // Streaming: synthetic pair is already in history — LLM sees it on next turn.
-                    }
-                }
-                catch {
-                    // Stream broke (daemon restart, socket disconnect). Retry after delay.
-                }
-                // Wait before reconnecting to avoid tight retry loops.
-                if (!cancelled) {
-                    await new Promise((r) => setTimeout(r, 2_000));
-                }
-            } // end while(!cancelled)
-        };
-        void run();
-        return () => {
-            cancelled = true;
-        };
-    }, [headlessRunKernel, localControlManager]);
-    // Cleanup wall-time interval on unmount
-    useEffect(() => {
-        return () => {
-            if (wallTimeIntervalRef.current) {
-                clearInterval(wallTimeIntervalRef.current);
-            }
-        };
-    }, []);
-    // Sync module-level shutdown state so startInkRepl can run graceful
-    // shutdown after the Ink app exits. Updated once on mount and whenever
-    // sessionHistory changes. Session ID and Memoria session refs are synced
-    // at their assignment sites (handleSubmit, handleSelectSession, /clear).
-    useEffect(() => {
-        _shutdownState.sessionHistory = sessionHistory ?? null;
-        _shutdownState.memoriaFactory = memoriaFactoryRef.current;
-    }, [sessionHistory]);
-    const handleCommandRef = useRef(undefined);
-    const continuePausedRunRef = useRef(null);
-    const handleSelectModelRef = useRef(undefined);
-    // The REPL no longer owns a per-submit RunSession or runner loop.
-    useEffect(() => {
-        let cancelled = false;
-        (async () => {
-            try {
-                const name = await aria.recallUserName();
-                if (cancelled)
-                    return;
-                setUserName(name);
-                const primary = session.getPrimary();
-                let memoria;
-                if (primary) {
-                    const arionMem = await session.getArionMemoria(primary);
-                    memoria = arionMem ?? aria.components.memoria;
-                    if (primary.preferredModel)
-                        setModel(primary.preferredModel);
-                }
-                else {
-                    memoria = aria.components.memoria;
-                }
-                const count = await memoria.count();
-                if (cancelled)
-                    return;
-                setMemoryCount(count);
-            }
-            catch {
-                /* user name is optional */
-            }
-        })();
-        return () => {
-            cancelled = true;
-        };
-    }, [aria, session]);
-    useEffect(() => {
-        let cancelled = false;
-        (async () => {
-            try {
-                const { resultFrame } = await dispatchHeadlessCommand("arion.list", {});
-                if (!resultFrame) {
-                    throw new Error("arion.list produced no result frame");
-                }
-                if (!resultFrame.ok) {
-                    throw new Error(resultFrame.error.message);
-                }
-                const list = resultFrame.result.arions ?? [];
-                if (cancelled)
-                    return;
-                setArions(list.map((a) => ({
-                    name: a.name,
-                    emoji: a.emoji,
-                    color: a.color,
-                    description: a.personality?.traits?.slice(0, 2).join(", ") || "",
-                    isActive: session.isActive(a.name),
-                    isResting: a.status === "resting",
-                })));
-            }
-            catch (error) {
-                if (cancelled)
-                    return;
-                setMessages((prev) => [
-                    ...prev,
-                    createErrorMessage(`Failed to load arions: ${error.message}`),
-                ]);
-            }
-        })();
-        return () => {
-            cancelled = true;
-        };
-    }, [dispatchHeadlessCommand, session]);
-    // ── Runtime-owned peer snapshot ───────────────────────────────────────────
-    // The TUI is a pure client. Nearby LAN discovery and connected peer state
-    // both come from LocalControlApi, not from client-owned discovery services.
-    useEffect(() => {
-        let active = true;
-        let interval = null;
-        const dispatchSnapshot = async (op, input) => {
-            if (!headlessRunKernel) {
-                return null;
-            }
-            let resultFrame = null;
-            for await (const frame of headlessRunKernel.dispatch({
-                kind: "request",
-                requestId: `${op}:${randomUUID()}`,
-                op,
-                input,
-            })) {
-                if (frame.kind === "result") {
-                    resultFrame = frame;
-                }
-            }
-            return resultFrame;
-        };
-        const startPolling = async () => {
-            const poll = async () => {
-                try {
-                    const [peerResult, nearbyResult, clientResult] = await Promise.all([
-                        dispatchSnapshot("peer.list", {}),
-                        dispatchSnapshot("peer.list_nearby", {}),
-                        dispatchSnapshot("client.list", {}),
-                    ]);
-                    if (!active || !peerResult?.ok || !nearbyResult?.ok || !clientResult?.ok)
-                        return;
-                    const peerViews = (peerResult.result.peers ?? []);
-                    const nearbyPeerViews = (nearbyResult.result.peers ?? []);
-                    const attachedClientViews = (clientResult.result.clients ??
-                        []);
-                    const lanPeers = nearbyPeerViews.map((peer) => ({
-                        displayNameSnapshot: peer.displayNameSnapshot,
-                        nodeId: peer.nodeId,
-                        host: peer.host,
-                        port: peer.port,
-                        principalFingerprint: peer.principalFingerprint,
-                        version: peer.version,
-                        tlsCaFingerprint: peer.tlsCaFingerprint,
-                        transport: peer.transport,
-                        status: peer.status,
-                    }));
-                    const wanPeers = peerViews
-                        .filter((peer) => peer.transportState === "connected")
-                        .map((peer) => ({
-                        displayNameSnapshot: peer.displayNameSnapshot ?? peer.nodeId,
-                        nodeId: peer.nodeId,
-                        version: "runtime",
-                        transport: "wan",
-                        status: "connected",
-                    }));
-                    setNearbyPeers(mergeDiscoveredPeersByIdentity(lanPeers, wanPeers));
-                    setLocalClients(attachedClientViews.map((client) => ({
-                        clientId: client.clientId,
-                        clientKind: client.clientKind,
-                        displayLabel: client.displayLabel,
-                        self: client.self,
-                    })));
-                }
-                catch (err) {
-                    // Local control or runtime peer snapshot unavailable — retry next interval
-                    if (isSessionExpiredError(err)) {
-                        active = false;
-                        if (interval)
-                            clearInterval(interval);
-                        interval = null;
-                        return;
-                    }
-                }
-            };
-            await poll(); // Initial poll
-            interval = setInterval(poll, 30_000); // Poll every 30s
-            if (!active && interval) {
-                clearInterval(interval);
-                interval = null;
-            }
-        };
-        startPolling();
-        return () => {
-            active = false;
-            if (interval)
-                clearInterval(interval);
-        };
-    }, [headlessRunKernel]);
-    // Do not probe provider APIs on TUI startup.
-    // Interactive sessions should render immediately from the static registry
-    // and only refresh discovery on explicit user action.
-    const knownModelKeys = useMemo(() => new Set(MODEL_REGISTRY.map((m) => `${m.provider}:${m.id}`)), []);
-    const selectableModels = useMemo(() => getCliSelectableModels(availableModels), [availableModels]);
-    const models = selectableModels.map((m) => ({
-        name: m.shortName,
-        value: toProviderQualifiedModelValue(m),
-        description: m.description || "",
-        provider: m.provider,
-        isCurrent: m.shortName === model,
-        knownModel: knownModelKeys.has(`${m.provider}:${m.id}`),
-    }));
-    const refreshArionsList = useCallback(async () => {
-        try {
-            const { resultFrame } = await dispatchHeadlessCommand("arion.list", {});
-            if (!resultFrame) {
-                throw new Error("arion.list produced no result frame");
-            }
-            if (!resultFrame.ok) {
-                throw new Error(resultFrame.error.message);
-            }
-            const list = resultFrame.result.arions ?? [];
-            setArions(list.map((a) => ({
-                name: a.name,
-                emoji: a.emoji,
-                color: a.color,
-                description: a.personality?.traits?.slice(0, 2).join(", ") || "",
-                isActive: session.isActive(a.name),
-                isResting: a.status === "resting",
-            })));
-        }
-        catch (error) {
-            log.warn("Failed to refresh arions list:", error.message);
-        }
-    }, [dispatchHeadlessCommand, session]);
-    const getCurrentMemoria = useCallback(async () => {
-        const primary = session.getPrimary();
-        if (primary) {
-            const arionMemoria = await session.getArionMemoria(primary);
-            if (arionMemoria)
-                return arionMemoria;
-        }
-        return aria.components.memoria;
-    }, [session, aria]);
-    const loadMemories = useCallback(async () => {
-        setIsLoadingMemories(true);
-        try {
-            const memoria = await getCurrentMemoria();
-            const recentMemories = await memoria.list({ limit: 100 });
-            setMemories(recentMemories.map((m) => ({
-                id: m.id,
-                content: m.content,
-                network: m.network,
-                createdAt: m.createdAt ?? new Date(),
-                importance: m.importance,
-            })));
-            const count = await memoria.count();
-            setMemoryCount(count);
-        }
-        catch (error) {
-            setMemories([]);
-            setMessages((prev) => [
-                ...prev,
-                createErrorMessage(`Failed to load memories: ${error.message}`),
-            ]);
-        }
-        finally {
-            setIsLoadingMemories(false);
-        }
-    }, [getCurrentMemoria]);
-    const loadSessions = useCallback(() => {
-        if (!sessionHistory)
-            return;
-        try {
-            const page = sessionPageRef.current;
-            const offset = page * SESSION_PAGE_SIZE;
-            const list = sessionHistory.listSessions(SESSION_PAGE_SIZE, offset);
-            setSessions(list);
-        }
-        catch (error) {
-            log.warn("Failed to load sessions:", error);
-        }
-    }, [sessionHistory]);
-    const handleSearchSessions = useCallback((query) => {
-        if (!sessionHistory)
-            return;
-        try {
-            const trimmed = query.trim();
-            sessionSearchQueryRef.current = trimmed;
-            sessionPageRef.current = 0;
-            // Cancel any in-flight scheduled search to keep typing responsive.
-            if (sessionSearchDebounceRef.current) {
-                clearTimeout(sessionSearchDebounceRef.current);
-                sessionSearchDebounceRef.current = null;
-            }
-            // Empty query should feel instant.
-            if (!trimmed) {
-                setSessions(sessionHistory.listSessions(SESSION_PAGE_SIZE, 0));
-                return;
-            }
-            // Deep FTS search is more expensive than metadata LIKE.
-            // Run it asynchronously with a short debounce so keypress handling stays snappy.
-            const seq = ++sessionSearchSeqRef.current;
-            sessionSearchDebounceRef.current = setTimeout(() => {
-                try {
-                    const next = sessionHistory.searchSessionsFts(trimmed, SESSION_PAGE_SIZE, 0);
-                    // Ignore stale results if user kept typing.
-                    if (seq !== sessionSearchSeqRef.current)
-                        return;
-                    if (sessionSearchQueryRef.current !== trimmed)
-                        return;
-                    setSessions(next);
-                }
-                catch (error) {
-                    log.warn("Failed to execute scheduled session search:", error);
-                }
-            }, 120);
-        }
-        catch (error) {
-            log.warn("Failed to search sessions:", error);
-        }
-    }, [sessionHistory]);
-    useEffect(() => {
-        return () => {
-            if (sessionSearchDebounceRef.current) {
-                clearTimeout(sessionSearchDebounceRef.current);
-                sessionSearchDebounceRef.current = null;
-            }
-        };
-    }, []);
-    const handleLoadMoreSessions = useCallback((direction) => {
-        if (!sessionHistory)
-            return;
-        try {
-            const nextPage = direction === "next"
-                ? sessionPageRef.current + 1
-                : Math.max(0, sessionPageRef.current - 1);
-            const offset = nextPage * SESSION_PAGE_SIZE;
-            const query = sessionSearchQueryRef.current;
-            const next = query
-                ? sessionHistory.searchSessionsFts(query, SESSION_PAGE_SIZE, offset)
-                : sessionHistory.listSessions(SESSION_PAGE_SIZE, offset);
-            if (direction === "next" && next.length === 0)
-                return;
-            sessionPageRef.current = nextPage;
-            setSessions(next);
-        }
-        catch (error) {
-            log.warn("Failed to paginate sessions:", error);
-        }
-    }, [sessionHistory]);
-    // Crash recovery — process incomplete sessions from previous runs.
-    // Delegates to recoverCrashedSessions() which handles extraction for incomplete sessions.
-    useEffect(() => {
-        const recoveryController = new AbortController();
-        const runRecovery = async () => {
-            if (!sessionHistory)
-                return;
-            try {
-                const memoria = await getCurrentMemoria();
-                if (recoveryController.signal.aborted)
-                    return;
-                const recovery = await recoverCrashedSessions({
-                    sessionHistory,
-                    memoria: memoria,
-                    router,
-                    signal: recoveryController.signal,
-                });
-                if (!recoveryController.signal.aborted && recovery.recovered > 0) {
-                    log.debug(`[InkREPL] Recovered learning from ${recovery.recovered} incomplete session${recovery.recovered === 1 ? "" : "s"}.`);
-                }
-            }
-            catch (err) {
-                log.warn("[InkREPL] Crash recovery failed:", err);
-            }
-        };
-        void runRecovery();
-        return () => {
-            recoveryController.abort();
-        };
-    }, [sessionHistory, getCurrentMemoria, router]);
-    const bindMemoriaSession = useCallback(async (sessionId) => {
-        try {
-            const mem = await getCurrentMemoria();
-            if ("session" in mem && typeof mem.session === "function") {
-                mem.session(sessionId);
-            }
-            if ("endSession" in mem && typeof mem.endSession === "function") {
-                memoriaSessionRef.current = mem;
-                _shutdownState.memoriaSession = memoriaSessionRef.current;
-            }
-        }
-        catch (err) {
-            log.warn("[InkREPL] Memoria session start failed (non-critical):", err);
-        }
-    }, [getCurrentMemoria]);
-    const endMemoriaSession = useCallback(async (sessionId) => {
-        if (!sessionId || !memoriaSessionRef.current)
-            return;
-        try {
-            await memoriaSessionRef.current.endSession(sessionId);
-        }
-        catch (err) {
-            log.warn("[InkREPL] Memoria session end failed (non-critical):", err);
-        }
-    }, []);
-    const setSessionMessagesFromConversation = useCallback((messages) => {
-        sessionMessagesRef.current = repairToolCallPairing(toModelMessages(messages).filter((m) => m.role !== "system"));
-    }, []);
-    const refreshSessionMessagesFromStorage = useCallback((sessionId) => {
-        if (!sessionHistory)
-            return;
-        const loaded = sessionHistory.loadSessionMessages(sessionId);
-        if (!loaded)
-            return;
-        setSessionMessagesFromConversation(loaded.messages);
-    }, [sessionHistory, setSessionMessagesFromConversation]);
-    const resetStaticRenderer = useCallback(() => {
-        setStaticRenderEpoch((n) => n + 1);
-    }, []);
-    // Clear terminal and remount <Static> after resize settles (Gemini-CLI approach).
-    // During drag-resize, Ink's live zone output wraps at intermediate widths and
-    // eraseLines() can't track the visual row count accurately, leaving ghost lines.
-    // Height-only shrinks have the same problem: the cursor/footer can wind up
-    // below the visible viewport unless we force a full redraw at the new size.
-    // After the resize stabilises (100ms debounce) we wipe the screen and force
-    // <Static> to re-render all committed history at the correct new dimensions.
-    const { columns: terminalColumns, rows: terminalRows } = useTerminalSize();
-    const isFirstResize = useRef(true);
-    useEffect(() => {
-        if (isFirstResize.current) {
-            isFirstResize.current = false;
-            return;
-        }
-        const timer = setTimeout(() => {
-            process.stdout.write("\x1b[2J\x1b[H");
-            resetStaticRenderer();
-        }, 100);
-        return () => clearTimeout(timer);
-    }, [terminalColumns, terminalRows, resetStaticRenderer]);
-    const publishResumeMarker = useCallback((sessionId, arionName) => {
-        try {
-            writeRelaunchMarker({
-                sessionId,
-                arionName,
-                pid: process.ppid || process.pid,
-                timestamp: new Date().toISOString(),
-            });
-        }
-        catch (error) {
-            log.debug(`[InkREPL] Failed to publish relaunch marker: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }, []);
-    const handleSelectSession = useCallback(async (sessionId) => {
-        if (!sessionHistory)
-            return;
-        // Block session restore while streaming to prevent data corruption (R2-C2 fix)
-        if (isStreamingRef.current)
-            return;
-        try {
-            setStallPhase("ink-repl:resume:session.load");
-            const { resultFrame } = await dispatchHeadlessCommand("session.load", { sessionId });
-            clearStallPhase();
-            if (!resultFrame) {
-                throw new Error("session.load produced no result frame");
-            }
-            if (!resultFrame.ok) {
-                setMessages((prev) => [
-                    ...prev,
-                    createErrorMessage(resultFrame.error.message || `Session not found: ${sessionId}`),
-                ]);
-                return;
-            }
-            const loadedState = resultFrame.result;
-            const loaded = loadedState.session;
-            if (!loaded) {
-                setMessages((prev) => [...prev, createErrorMessage(`Session not found: ${sessionId}`)]);
-                return;
-            }
-            // SQLite first (fast, has user + assistant + tool messages).
-            // JSONL fills gaps only on crash recovery — skip the expensive JSONL replay
-            // (30MB+ sync read) when the session completed normally (no data loss).
-            let messages = loaded.messages;
-            const runtimeState = sessionHistory.getSessionRuntimeState(sessionId);
-            const needsCrashRecovery = !runtimeState || runtimeState.stateStatus !== "completed";
-            if (needsCrashRecovery) {
-                setStallPhase("ink-repl:resume:jsonlCrashRecovery");
-                const ariaDir = process.env.ARIA_HOME ?? `${process.env.HOME}/.aria`;
-                const arionName = loaded.arion || session.getPrimary()?.name || "ARIA";
-                const jsonlPath = findJsonlForSession(ariaDir, arionName, sessionId);
-                const { messages: merged, backfillMessages } = mergeWithJsonlRecovery(loaded.messages, jsonlPath);
-                messages = merged;
-                // Backfill SQLite so the index catches up with JSONL source of truth
-                if (backfillMessages.length > 0) {
-                    sessionHistory.persistMessagesNonBlocking(sessionId, backfillMessages);
-                    log.debug(`[InkREPL] JSONL→SQLite backfill: ${backfillMessages.length} messages recovered`);
-                }
-                clearStallPhase();
-            }
-            // Session identity is pull-based: Memoria reads sessionIdRef via
-            // the sessionResolver passed to MemoriaPool. No explicit bind/end
-            // calls needed — setting the ref is sufficient. endMemoriaSession
-            // only runs at process shutdown (embedding flush before exit).
-            session.clearHistory();
-            sessionIdRef.current = sessionId;
-            setPendingResumeSessionId(sessionId);
-            setPendingArionName(loaded.arion || session.getPrimary()?.name || "ARIA");
-            publishResumeMarker(sessionId, loaded.arion || session.getPrimary()?.name || "ARIA");
-            _shutdownState.sessionId = sessionId;
-            // Yield to event loop so Ink renders any pending frames before
-            // heavy synchronous post-processing (toModelMessages, repairToolCallPairing).
-            await new Promise((r) => setTimeout(r, 0));
-            // Reconstruct sessionMessagesRef from ConversationMessage[] via toModelMessages,
-            // repairing any interrupted tool chains from crashed sessions (A-2 review fix)
-            setStallPhase("ink-repl:resume:setSessionMessages");
-            setSessionMessagesFromConversation(messages);
-            clearStallPhase();
-            // Reset static renderer before replacing conversation list so every
-            // resume renders, not just the first one.
-            resetStaticRenderer();
-            setMessages([
-                createSystemMessage(`Resumed session (${messages.length} messages from ${loaded.arion})`),
-                ...messages,
-            ]);
-            setSpans([]);
-            setPipelineTiming(undefined);
-            // Only add user/assistant/system to ArionSession history (consistent
-            // with normal operation which never adds tool messages — A-4 review fix).
-            // For assistant messages with toolCalls AND content, preserve the content
-            // portion so contribution gate sees it (R2-C4 fix).
-            setStallPhase("ink-repl:resume:appendSessionHistory");
-            for (const msg of messages) {
-                if (msg.role === "tool")
-                    continue;
-                const textContent = msg.content
-                    .filter((b) => b.type === "text")
-                    .map((b) => b.text)
-                    .join("");
-                if (msg.role === "assistant" && !textContent)
-                    continue; // skip tool-only assistant messages
-                appendSessionHistoryText({
-                    role: msg.role,
-                    content: textContent,
-                    arion: msg.arion?.name,
-                });
-            }
-            clearStallPhase();
-            if (loadedState.pendingInteraction) {
-                await continuePausedRunRef.current?.({
-                    pendingInteraction: {
-                        interactionId: loadedState.pendingInteraction.interactionId,
-                        source: loadedState.pendingInteraction.source,
-                        interaction: loadedState.pendingInteraction.prompt,
-                    },
-                    startedAt: Date.now(),
-                    abortSignal: new AbortController().signal,
-                });
-            }
-        }
-        catch (error) {
-            clearStallPhase();
-            setMessages((prev) => [
-                ...prev,
-                createErrorMessage(`Error resuming session: ${getErrorMessage(error)}`),
-            ]);
-        }
-    }, [
-        sessionHistory,
-        session,
-        endMemoriaSession,
-        bindMemoriaSession,
-        dispatchHeadlessCommand,
-        publishResumeMarker,
-        appendSessionHistoryText,
-        setSessionMessagesFromConversation,
-        resetStaticRenderer,
-    ]);
-    const persistResumedMessages = useCallback(async (input) => {
-        const nextMessages = Array.isArray(input.result.messages)
-            ? repairToolCallPairing(structuredClone(input.result.messages.filter((msg) => msg.role !== "system")))
-            : sessionMessagesRef.current;
-        const previousCount = sessionMessagesRef.current.length;
-        const deltaMessages = nextMessages.slice(previousCount);
-        if (deltaMessages.length > 0) {
-            const deltaConversation = fromModelMessages(deltaMessages, {
-                arion: input.respondingArionName
-                    ? {
-                        name: input.respondingArionName,
-                        emoji: "🦋",
-                    }
-                    : undefined,
-            });
-            const sid = sessionIdRef.current;
-            if (sessionHistory && sid) {
-                sessionHistory.persistMessagesNonBlocking(sid, deltaConversation);
-            }
-            setMessages((prev) => [...prev, ...deltaConversation]);
-        }
-        sessionMessagesRef.current = nextMessages;
-        const usage = input.result.usage;
-        setMetrics((prev) => ({
-            ...prev,
-            ...(typeof input.result.turnCount === "number"
-                ? { turnCount: input.result.turnCount }
-                : {}),
-            ...(typeof usage?.totalTokens === "number" ? { totalTokens: usage.totalTokens } : {}),
-            ...(typeof usage?.estimatedCost === "number" ? { estimatedCost: usage.estimatedCost } : {}),
-        }));
-        if (input.result.state) {
-            return input.result.state;
-        }
-        if (!input.result.success) {
-            throw Object.assign(new Error(resolveTrustedRuntimeErrorMessage(input.result.error ?? "Run resume failed", input.result.diagnostic) ??
-                input.result.error ??
-                "Run resume failed"), {
-                ...(input.result.diagnostic === undefined
-                    ? {}
-                    : { diagnostic: input.result.diagnostic }),
-            });
-        }
-        appendAssistantConversationHistory(nextMessages, input.respondingArionName);
-        setResponseTime((Date.now() - input.startedAt) / 1000);
-        try {
-            const memoria = await getCurrentMemoria();
-            const count = await memoria.count();
-            setMemoryCount(count);
-        }
-        catch (memErr) {
-            log.warn("Memory finalization failed:", memErr);
-        }
-        await refreshArionsList();
-        return null;
-    }, [appendAssistantConversationHistory, getCurrentMemoria, refreshArionsList, sessionHistory]);
-    const respondToHeadlessRunInteraction = useCallback(async (input) => {
-        if (!headlessRunKernel) {
-            throw new Error("Headless run kernel unavailable for REPL resume");
-        }
-        const localControl = await waitForLocalControlReady(input.abortSignal);
-        if (!localControl) {
-            throw new Error("Local runtime control unavailable for REPL resume");
-        }
-        let nextInteraction = null;
-        let resultFrame = null;
-        for await (const frame of headlessRunKernel.dispatch({
-            kind: "interaction.respond",
-            requestId: `${sessionIdRef.current ?? "session"}:interaction:${randomUUID()}`,
-            interactionId: input.interactionId,
-            response: input.response,
-        }, { signal: input.abortSignal })) {
-            if (input.abortSignal?.aborted)
-                break;
-            if (frame.kind === "interaction.required") {
-                nextInteraction = {
-                    interactionId: frame.interactionId,
-                    source: frame.source,
-                    interaction: frame.interaction,
-                };
-            }
-            else if (frame.kind === "result") {
-                resultFrame = frame;
-            }
-        }
-        if (input.abortSignal?.aborted) {
-            return nextInteraction;
-        }
-        if (!resultFrame) {
-            throw new Error("Headless run interaction produced no result frame");
-        }
-        if (resultFrame.ok) {
-            await persistResumedMessages({
-                result: resultFrame.result,
-                respondingArionName: input.respondingArionName,
-                startedAt: input.startedAt,
-            });
-            return null;
-        }
-        if (resultFrame.error.code === "INTERACTION_REQUIRED") {
-            return nextInteraction;
-        }
-        throw Object.assign(new Error(resultFrame.error.message), {
-            ...(resultFrame.error.details === undefined
-                ? {}
-                : { diagnostic: resultFrame.error.details }),
-        });
-    }, [headlessRunKernel, persistResumedMessages, waitForLocalControlReady]);
-    const continuePausedRun = useCallback(async (input) => {
-        let pendingInteraction = input.pendingInteraction;
-        while (pendingInteraction?.interaction.kind === "tool_approval" &&
-            !input.abortSignal.aborted) {
-            const approved = await requestToolApproval({
-                toolName: pendingInteraction.interaction.toolName,
-                input: pendingInteraction.interaction.toolInput,
-                riskLevel: toApprovalRiskLevel(pendingInteraction.interaction.riskLevel),
-                ...(pendingInteraction.interaction.issues?.length
-                    ? { issues: pendingInteraction.interaction.issues }
-                    : {}),
-            });
-            pendingInteraction = await respondToHeadlessRunInteraction({
-                interactionId: pendingInteraction.interactionId,
-                response: { kind: "confirm", approved },
-                respondingArionName: input.respondingArionName,
-                startedAt: input.startedAt,
-                abortSignal: input.abortSignal,
-            });
-        }
-        if (input.abortSignal.aborted) {
-            return;
-        }
-        if (pendingInteraction?.interaction.kind === "questionnaire") {
-            const questions = pendingInteraction.interaction.questions;
-            setPendingAskUserResume({
-                interactionId: pendingInteraction.interactionId,
-                questions,
-                answers: [],
-                ...(input.respondingArionName ? { respondingArionName: input.respondingArionName } : {}),
-                startedAt: input.startedAt,
-            });
-            setMessages((prev) => [
-                ...prev,
-                createSystemMessage(formatAskUserResumePrompt(questions[0], 0, questions.length)),
-            ]);
-            setSpans([]);
-            await refreshArionsList();
-            return;
-        }
-        if (pendingInteraction) {
-            const pausedMessage = pendingInteraction.interaction.kind === "tool_approval"
-                ? `Run paused: approval required for ${pendingInteraction.interaction.toolName}${formatApprovalInput(pendingInteraction.interaction.toolInput)
-                    ? ` (${formatApprovalInput(pendingInteraction.interaction.toolInput)})`
-                    : ""}.`
-                : "Run paused and requires interaction to continue.";
-            setMessages((prev) => [...prev, createSystemMessage(pausedMessage)]);
-            setSpans([]);
-            await refreshArionsList();
-        }
-    }, [refreshArionsList, requestToolApproval, respondToHeadlessRunInteraction]);
-    continuePausedRunRef.current = continuePausedRun;
-    // handleSubmit is SYNCHRONOUS — it validates, sets guards, and fires the
-    // async turn as a detached promise. This ensures Ink's render/input loop
-    // is NEVER blocked by model calls, tool execution, or cleanup work.
-    // All async work lives in the body below; errors are caught internally.
-    const handleSubmit = useCallback((input) => {
-        if (isStreamingRef.current) {
-            // Queue message to send after current stream ends.
-            // Combine with existing queued message instead of overwriting.
-            // Multiple submissions during streaming merge into one message.
-            queuedMessageRef.current = queuedMessageRef.current
-                ? queuedMessageRef.current + "\n\n" + input
-                : input;
-            setQueuedMessage(queuedMessageRef.current);
-            return;
-        }
-        // Fire-and-forget: the entire async turn runs detached from Ink's
-        // render loop. Errors are caught internally — never an unhandled rejection.
-        void (async () => {
-            if (pendingAskUserResume) {
-                appendUserConversationInput(input);
-                const nextAnswers = [...pendingAskUserResume.answers, input];
-                if (nextAnswers.length < pendingAskUserResume.questions.length) {
-                    setPendingAskUserResume({
-                        ...pendingAskUserResume,
-                        answers: nextAnswers,
-                    });
-                    setMessages((prev) => [
-                        ...prev,
-                        createSystemMessage(formatAskUserResumePrompt(pendingAskUserResume.questions[nextAnswers.length], nextAnswers.length, pendingAskUserResume.questions.length)),
-                    ]);
-                    return;
-                }
-                abortController.current = new AbortController();
-                const resumeAbortSignal = abortController.current.signal;
-                isStreamingRef.current = true;
-                msgDispatch({ type: "START_TURN" });
-                setPendingAskUserResume(null);
-                try {
-                    const nextInteraction = await respondToHeadlessRunInteraction({
-                        interactionId: pendingAskUserResume.interactionId,
-                        response: {
-                            kind: "questionnaire",
-                            answers: nextAnswers,
-                        },
-                        respondingArionName: pendingAskUserResume.respondingArionName,
-                        startedAt: pendingAskUserResume.startedAt,
-                        abortSignal: resumeAbortSignal,
-                    });
-                    await continuePausedRun({
-                        pendingInteraction: nextInteraction,
-                        respondingArionName: pendingAskUserResume.respondingArionName,
-                        startedAt: pendingAskUserResume.startedAt,
-                        abortSignal: resumeAbortSignal,
-                    });
-                }
-                catch (error) {
-                    logInternalRunFailure(error);
-                    setMessages((prev) => [
-                        ...prev,
-                        createErrorMessage(`Error: ${error.message}`),
-                    ]);
-                }
-                finally {
-                    abortController.current = null;
-                    isStreamingRef.current = false;
-                    msgDispatch({ type: "DISCARD_STREAMING" });
-                    setSpans([]);
-                }
-                return;
-            }
-            const slashCmd = parseSlashCommand(input);
-            if (slashCmd && handleCommandRef.current) {
-                await handleCommandRef.current(slashCmd.command, slashCmd.args);
-                return;
-            }
-            sounds.onPromptSubmit();
-            // Create AbortController BEFORE setting streaming state so that
-            // handleCancel() always finds a non-null controller if isStreaming is true.
-            // Closes the race window where ESC could fire between setIsStreaming(true)
-            // and controller creation, resulting in a no-op cancel.
-            abortController.current = new AbortController();
-            const abortSignal = abortController.current.signal;
-            // Set streaming guard after controller exists to prevent
-            // reentrancy from rapid double-submit (R2-C8 fix)
-            isStreamingRef.current = true;
-            msgDispatch({ type: "START_TURN" });
-            const parsed = parseMessage(input);
-            // Lazily create SQLite session on first submit (FK constraint)
-            if (sessionHistory && !sessionIdRef.current) {
-                try {
-                    const primary = session.getPrimary();
-                    const arionName = primary?.name || "ARIA";
-                    sessionIdRef.current = sessionHistory.createSession(arionName, model);
-                    setPendingResumeSessionId(sessionIdRef.current);
-                    setPendingArionName(arionName);
-                    publishResumeMarker(sessionIdRef.current, arionName);
-                    _shutdownState.sessionId = sessionIdRef.current;
-                    // Notify supervisor of session ID immediately for crash recovery.
-                    // If the child crashes, the supervisor knows which session to resume.
-                    try {
-                        const send = process.send;
-                        if (typeof send === "function") {
-                            send({
-                                type: "aria-relaunch",
-                                resumeSessionId: sessionIdRef.current,
-                                arionName,
-                            });
-                        }
-                    }
-                    catch {
-                        // No IPC channel — not supervised
-                    }
-                    // Start a Memoria session with the same ID so memories extracted during
-                    // this CLI session are tagged with source.session for consolidation grouping.
-                    await bindMemoriaSession(sessionIdRef.current);
-                }
-                catch (err) {
-                    log.warn("[InkREPL] SQLite session creation failed (non-fatal):", err);
-                }
-            }
-            // Lazily create JSONL event logger on first submit (one file per CLI session).
-            // Uses the same sessionId as SQLite history for cross-referencing.
-            if (!_shutdownState.jsonlLogger && ariaDisplayConfig.persistence.jsonlEnabled) {
-                const activeArionName = session.getPrimary()?.name || "ARIA";
-                const ariaHome = process.env.ARIA_HOME ?? `${process.env.HOME}/.aria`;
-                const logDir = `${ariaHome}/arions/${activeArionName}/logs`;
-                _shutdownState.jsonlLogger = new JsonlEventLogger({
-                    logDir,
-                    sessionId: sessionIdRef.current || randomUUID(),
-                    retentionDays: ariaDisplayConfig.persistence.jsonlRetentionDays,
-                    maxSizeMb: ariaDisplayConfig.persistence.jsonlMaxSizeMb,
-                });
-                void _shutdownState.jsonlLogger.rotate().catch((err) => {
-                    log.warn("[InkREPL] JSONL log rotation failed:", err);
-                });
-            }
-            for (const mention of parsed.mentions) {
-                if (!session.isActive(mention)) {
-                    try {
-                        await session.activate(mention);
-                    }
-                    catch (error) {
-                        const msg = error.message?.toLowerCase() || "";
-                        if (!msg.includes("not found") && !msg.includes("unknown")) {
-                            log.warn(`Failed to activate @${mention}:`, error.message);
-                        }
-                    }
-                }
-            }
-            const addressedArions = [];
-            for (const mention of parsed.mentions) {
-                const arion = session
-                    .getActiveArions()
-                    .find((a) => a.name.toLowerCase() === mention.toLowerCase());
-                if (arion)
-                    addressedArions.push(arion);
-            }
-            if (addressedArions.length === 0) {
-                const primary = session.getPrimary();
-                if (primary)
-                    addressedArions.push(primary);
-            }
-            // Persist + render user message BEFORE loop (crash safety).
-            appendUserConversationInput(input);
-            // Reset spans for this run
-            setSpans([]);
-            setPipelineTiming(undefined);
-            const startTime = Date.now();
-            // Reset mesh message count — user is now interacting, messages will be in context
-            setMeshMessageCount(0);
-            // Reset observability metrics for this run and start wall-time timer
-            runStartTimeRef.current = startTime;
-            setMetrics({
-                turnCount: 0,
-                totalTokens: 0,
-                estimatedCost: 0,
-                wallTimeSeconds: 0,
-                contextTokens: 0,
-                contextStale: false,
-            });
-            // Wall-time tracking — merged into the render scheduler below (no separate timer).
-            // A single timer for ALL streaming UI updates prevents independent render triggers.
-            if (wallTimeIntervalRef.current)
-                clearInterval(wallTimeIntervalRef.current);
-            wallTimeSecondsRef.current = 0;
-            wallTimeIntervalRef.current = null; // No separate timer — render scheduler handles it
-            // TurnAccumulator replaces localTimeline, localTools, fullContent, liveThinkingContent,
-            // toolArgsAccumulator — it ingests RunEvents and flushes ConversationMessages at turn boundaries.
-            const accumulator = new TurnAccumulator();
-            // --- Render scheduler (SINGLE source of renders during streaming) ---
-            // ALL streaming UI updates happen here: preview content, wall-time elapsed,
-            // and animation frame advancement.  No other timers trigger renders.
-            // This ensures ONE atomic terminal write per tick — no flickering.
-            const PREVIEW_RENDER_INTERVAL_MS = 100; // ~10 fps — smooth without flicker
-            let previewDirty = false;
-            const previewRenderTimer = setInterval(() => {
-                // --- All streaming UI state updates happen HERE, in one callback ---
-                // React batches setState calls within the same synchronous callback,
-                // producing exactly ONE Ink render per tick — ONE atomic terminal write.
-                // 1. Wall-time elapsed (was separate 500ms timer)
-                const newSeconds = Math.floor((Date.now() - runStartTimeRef.current) / 1000);
-                if (newSeconds !== wallTimeSecondsRef.current) {
-                    wallTimeSecondsRef.current = newSeconds;
-                    pendingMetrics = { ...(pendingMetrics ?? {}), wallTimeSeconds: newSeconds };
-                }
-                // 2. Accumulated metrics from events (usage_update, turn_complete, tool_result)
-                if (pendingMetrics) {
-                    setMetrics((prev) => ({ ...prev, ...pendingMetrics }));
-                    pendingMetrics = null;
-                }
-                // 3. Preview content from accumulator snapshot
-                if (previewDirty && accumulator.hasPendingContent()) {
-                    msgDispatch({ type: "UPDATE_STREAM", snapshot: [...accumulator.snapshot()] });
-                    previewDirty = false;
-                }
-            }, PREVIEW_RENDER_INTERVAL_MS);
-            let respondingArion;
-            let runHistory = [];
-            // The composing verb is shown in the indicator during TTFB wait. When the
-            // first thinking block arrives, it inherits this verb so the user sees
-            // continuity (same verb, accumulated time) rather than a jarring switch.
-            const composingVerb = pickRandomVerbPair();
-            // Pending metrics — accumulated during the event loop, flushed by the render scheduler.
-            // This prevents usage_update/turn_complete/tool_result events from triggering
-            // independent React renders that bypass the single-timer architecture.
-            let pendingMetrics = null;
-            try {
-                const respondingArions = await session.getRespondingArions(input, addressedArions, []);
-                respondingArion = respondingArions[0]?.arion || session.getPrimary();
-                // Track active arion for StatusBar display
-                setActiveArion(respondingArion?.name);
-                activeArionRef.current = respondingArion?.name;
-                // Initialize accumulator with arion + verb context
-                if (respondingArion) {
-                    accumulator.setArion({
-                        name: respondingArion.name,
-                        emoji: respondingArion.emoji ?? "🦋",
-                        color: respondingArion.color ?? undefined,
-                    });
-                }
-                accumulator.setVerb(composingVerb.present);
-                // Build a runtime-owned RunRequest for the attached local client.
-                const rsConfig = loadConfig();
-                if (!headlessRunKernel) {
-                    throw new Error("Headless run kernel unavailable for REPL submit");
-                }
-                const readyLocalControl = await waitForLocalControlReady(abortSignal);
-                if (abortSignal.aborted)
-                    return;
-                if (!readyLocalControl) {
-                    throw new Error("Local runtime control unavailable for REPL submit");
-                }
-                // Pass the full accumulated session history to the runner. Context window
-                // management is handled by ContextGuard.beforeModelCall() inside the runner
-                // (intelligent token-based compaction: masking → LLM summarization).
-                //
-                // Previously this hard-truncated to 20 user turns (MAX_TURNS), which was
-                // redundant with ContextGuard AND destructive: since sessionMessagesRef is
-                // replaced by the runner's messages_snapshot after each turn, truncated
-                // messages were permanently lost from the ref (compounding shrinkage).
-                // IMPORTANT: Build BEFORE the runner adds the current user input (runner.ts:876).
-                runHistory = repairToolCallPairing([...sessionMessagesRef.current]);
-                const sessionId = sessionIdRef.current;
-                let pendingInteraction = null;
-                let finalRunResult = null;
-                const approvalMode = autonomyToConfirmation(autonomyLevelRef.current).length > 0 ? "pause" : "approve";
-                const runRequest = {
-                    task: input,
-                    arion: activeArionRef.current || respondingArion?.name || rsConfig.activeArion || "ARIA",
-                    cwd: process.cwd(),
-                    ...(runHistory.length > 0 ? { history: runHistory } : {}),
-                    ...(modelRef.current ? { requestedModel: modelRef.current } : {}),
-                    ...(rsConfig.preferredTier
-                        ? { preferredTier: rsConfig.preferredTier }
-                        : {}),
-                    autonomy: autonomyLevelRef.current,
-                    approvalMode,
-                };
-                for await (const frame of headlessRunKernel.dispatch({
-                    kind: "request",
-                    requestId: sessionId ?? randomUUID(),
-                    op: "run.start",
-                    input: runRequest,
-                }, { signal: abortSignal })) {
-                    // Check abort at top of loop — break immediately so the
-                    // generator's finally{} block can run cleanup in the orchestrator.
-                    if (abortSignal.aborted)
-                        break;
-                    if (frame.kind === "interaction.required") {
-                        pendingInteraction = {
-                            interactionId: frame.interactionId,
-                            source: frame.source,
-                            interaction: frame.interaction,
-                        };
-                        continue;
-                    }
-                    if (frame.kind === "result") {
-                        finalRunResult = frame;
-                        continue;
-                    }
-                    const event = frame.event;
-                    // Persist every RunEvent to JSONL for debugging/replay
-                    _shutdownState.jsonlLogger?.log(event);
-                    // Warcraft sound notifications
-                    sounds.onRunEvent(event);
-                    // Track handoff events for accumulator arion context
-                    if (event.type === "handoff_start" || event.type === "handoff_result") {
-                        // Update respondingArion when a handoff completes
-                        if (event.type === "handoff_result") {
-                            const handoffTarget = session
-                                .getActiveArions()
-                                .find((a) => a.name.toLowerCase() === event.target.toLowerCase());
-                            if (handoffTarget) {
-                                respondingArion = handoffTarget;
-                                accumulator.setArion({
-                                    name: handoffTarget.name,
-                                    emoji: handoffTarget.emoji ?? "🦋",
-                                    color: handoffTarget.color ?? undefined,
-                                });
-                            }
-                        }
-                    }
-                    // Direct handlers (non-content events):
-                    if (event.type === "span_start") {
-                        const parentSpanId = "parentSpanId" in event && typeof event.parentSpanId === "string"
-                            ? event.parentSpanId
-                            : undefined;
-                        setSpans((prev) => [
-                            ...prev,
-                            {
-                                spanId: event.spanId,
-                                spanType: event.spanType,
-                                name: event.name,
-                                startTime: Date.now(),
-                                ...(parentSpanId ? { parentSpanId } : {}),
-                            },
-                        ]);
-                    }
-                    if (event.type === "span_end") {
-                        setSpans((prev) => prev.map((s) => s.spanId === event.spanId
-                            ? { ...s, endTime: Date.now(), durationMs: event.durationMs }
-                            : s));
-                    }
-                    if (event.type === "pipeline_timing") {
-                        setPipelineTiming(event.report);
-                    }
-                    if (event.type === "error") {
-                        throw new Error(resolveTrustedRuntimeErrorMessage(event.error.message, "diagnostic" in event.error ? event.error.diagnostic : undefined) ?? event.error.message);
-                    }
-                    if (event.type === "usage_update") {
-                        const usage = event.usage;
-                        if (typeof usage.inputTokens === "number" && typeof usage.outputTokens === "number") {
-                            accumulator.setTokenUsage({
-                                input: usage.inputTokens,
-                                output: usage.outputTokens,
-                            });
-                        }
-                        // Accumulate — render scheduler flushes in one batched render
-                        pendingMetrics = {
-                            ...(pendingMetrics ?? {}),
-                            ...(typeof usage.totalTokens === "number"
-                                ? { totalTokens: usage.totalTokens }
-                                : {}),
-                            ...(typeof usage.estimatedCost === "number"
-                                ? { estimatedCost: usage.estimatedCost }
-                                : {}),
-                            // Per-call inputTokens = current context window usage (how full it is)
-                            ...(typeof usage.inputTokens === "number"
-                                ? { contextTokens: usage.inputTokens }
-                                : {}),
-                            contextStale: false,
-                        };
-                        // Update status bar to reflect the actual model used by the router.
-                        // This handles cases where the configured model failed and the router
-                        // escalated/fell back to a different provider (e.g., OpenAI → Bedrock).
-                        if ("model" in event && typeof event.model === "string") {
-                            const actualShortName = toShortName(event.model);
-                            if (actualShortName !== model) {
-                                setModel(actualShortName);
-                                modelRef.current = actualShortName;
-                            }
-                        }
-                    }
-                    if (event.type === "turn_complete") {
-                        pendingMetrics = { ...(pendingMetrics ?? {}), turnCount: event.turnNumber };
-                    }
-                    if (event.type === "tool_result") {
-                        pendingMetrics = { ...(pendingMetrics ?? {}), contextStale: true };
-                    }
-                    // Content events → accumulator (data only — no render scheduling here)
-                    const signal = accumulator.ingest(event);
-                    if (signal === "flush") {
-                        const turnMessages = accumulator.flush();
-                        const sessionId = sessionIdRef.current;
-                        // Persist all flushed messages in a SINGLE transaction to avoid
-                        // N separate lock acquisitions. With multiple concurrent ARIA
-                        // processes sharing the same WAL-mode history.db, each BEGIN
-                        // IMMEDIATE can block on busy_timeout waiting for the write lock.
-                        // Batching reduces lock contention from N×100ms to 1×100ms.
-                        if (sessionHistory && sessionId) {
-                            sessionHistory.persistMessagesNonBlocking(sessionId, turnMessages);
-                        }
-                        // Atomic: commit flushed turn messages and clear streaming zone in one dispatch
-                        msgDispatch({ type: "COMMIT_TURN", flushed: turnMessages });
-                        // Mark clean so scheduler doesn't re-render stale state
-                        previewDirty = false;
-                    }
-                    else {
-                        // Any data event marks the preview as dirty for the render scheduler
-                        previewDirty = true;
-                    }
-                }
-                setObsCtx(null);
-                sounds.onResponseComplete();
-                // Stop render scheduler — streaming is complete, no more preview updates
-                clearInterval(previewRenderTimer);
-                // Flush one final render if dirty — ensures the last accumulated content
-                // (e.g. final text tokens or tool result) is visible before commit.
-                if (previewDirty && accumulator.hasPendingContent()) {
-                    msgDispatch({ type: "UPDATE_STREAM", snapshot: [...accumulator.snapshot()] });
-                    previewDirty = false;
-                }
-                // Stop wall-time timer now that the stream is complete
-                if (wallTimeIntervalRef.current) {
-                    clearInterval(wallTimeIntervalRef.current);
-                    wallTimeIntervalRef.current = null;
-                }
-                // Set final wall time
-                setMetrics((prev) => ({
-                    ...prev,
-                    wallTimeSeconds: (Date.now() - runStartTimeRef.current) / 1000,
-                }));
-                // CRITICAL: Reset streaming UI state IMMEDIATELY so React can render
-                // the input area while heavy post-processing runs. isStreamingRef stays
-                // true to guard handleSubmit against reentrancy — queued messages are
-                // drained at the bottom of this function after post-processing completes.
-                //
-                // Use COMMIT_AND_END (not DISCARD_STREAMING) to atomically commit any
-                // remaining content AND set streamCursor=null in a single reducer step.
-                // DISCARD_STREAMING slices items at streamCursor, which races with
-                // COMMIT_TURN — if React batches both dispatches or a timer-based
-                // UPDATE_STREAM sneaks in between, the final streamed text is lost.
-                if (accumulator.hasPendingContent()) {
-                    const finalMessages = accumulator.flush();
-                    const sid = sessionIdRef.current;
-                    if (sessionHistory && sid) {
-                        sessionHistory.persistMessagesNonBlocking(sid, finalMessages);
-                    }
-                    msgDispatch({ type: "COMMIT_AND_END", flushed: finalMessages });
-                }
-                else {
-                    msgDispatch({ type: "COMMIT_AND_END", flushed: [] });
-                }
-                setSpans([]);
-                setResponseTime((Date.now() - startTime) / 1000);
-                // Yield to the event loop so Ink renders the prompt (input area visible,
-                // streaming indicator hidden) BEFORE heavy post-processing blocks the thread.
-                // Without this yield, structuredClone + repairToolCallPairing + SQLite reads
-                // all run synchronously and the UI appears frozen at end of turn.
-                await new Promise((r) => setTimeout(r, 0));
-                // --- Heavy post-processing (UI already responsive) ---
-                // Capture sessionMessagesRef from final snapshot (AFTER loop, not in flush block).
-                // messages_snapshot fires at end of run. The runner maintains its own internal
-                // message array across turns — sessionMessagesRef is only needed for the NEXT user submission.
-                const snapshot = accumulator.getSnapshotMessages();
-                const snapshotFiltered = snapshot?.filter((m) => m.role !== "system");
-                // Only update sessionMessagesRef when the snapshot has real messages.
-                // Empty snapshots (from error/guardrail paths) must NOT wipe prior history —
-                // fall through to refreshSessionMessagesFromStorage instead.
-                const hasSnapshot = !!(snapshotFiltered && snapshotFiltered.length > 0);
-                if (hasSnapshot) {
-                    // Defensive copy via structuredClone so mutations in one run
-                    // cannot corrupt the next run's history through shared references.
-                    const ppT0 = performance.now();
-                    setStallPhase("ink-repl:structuredClone");
-                    const cloned = structuredClone(snapshotFiltered);
-                    const ppT1 = performance.now();
-                    setStallPhase("ink-repl:repairToolCallPairing");
-                    sessionMessagesRef.current = repairToolCallPairing(cloned);
-                    const ppT2 = performance.now();
-                    clearStallPhase();
-                    const cloneMs = ppT1 - ppT0;
-                    const repairMs = ppT2 - ppT1;
-                    if (process.env.DEBUG && cloneMs + repairMs > 100) {
-                        try {
-                            process.stderr.write(`[InkREPL][DIAG] post-processing: structuredClone=${cloneMs.toFixed(0)}ms ` +
-                                `repairToolCallPairing=${repairMs.toFixed(0)}ms ` +
-                                `(${snapshotFiltered.length} msgs)\n`);
-                        }
-                        catch {
-                            /* best effort */
-                        }
-                    }
-                }
-                else if (sessionHistory && sessionIdRef.current) {
-                    // If no snapshot was emitted (e.g. interrupted run paths), rehydrate
-                    // from persisted ConversationMessage rows so next turn history is correct.
-                    setStallPhase("ink-repl:refreshSessionMessagesFromStorage");
-                    refreshSessionMessagesFromStorage(sessionIdRef.current);
-                    clearStallPhase();
-                }
-                if (abortSignal.aborted) {
-                    if (accumulator.hasPendingContent()) {
-                        const abortedMessages = accumulator.flush();
-                        const sid = sessionIdRef.current;
-                        if (sessionHistory && sid) {
-                            sessionHistory.persistMessagesNonBlocking(sid, abortedMessages);
-                        }
-                        // Atomic: commit aborted content and end streaming in one dispatch
-                        msgDispatch({ type: "COMMIT_AND_END", flushed: abortedMessages });
-                    }
-                    else {
-                        msgDispatch({ type: "DISCARD_STREAMING" });
-                    }
-                    // Rehydrate session messages from storage so next turn has
-                    // correct history even after abort (same as the non-snapshot path).
-                    if (sessionHistory && sessionIdRef.current) {
-                        refreshSessionMessagesFromStorage(sessionIdRef.current);
-                    }
-                    setSpans([]);
-                    isStreamingRef.current = false;
-                    abortController.current = null;
-                    if (wallTimeIntervalRef.current) {
-                        clearInterval(wallTimeIntervalRef.current);
-                        wallTimeIntervalRef.current = null;
-                    }
-                    // DO NOT return — fall through to the drain block below so queued
-                    // messages submitted during streaming are dispatched (or cleared).
-                    // Previously this was `return`, silently dropping queued messages.
-                }
-                if (!abortSignal.aborted) {
-                    isStreamingRef.current = false;
-                    // isStreaming is now derived from streamCursor — already false from
-                    // DISCARD_STREAMING dispatched above.
-                    // Persistence is now handled per-turn by the accumulator flush inside the event loop.
-                    // No persistSnapshotMessages needed — messages are already in SQLite.
-                    if (!finalRunResult) {
-                        throw new Error("Headless run produced no result frame");
-                    }
-                    if (pendingInteraction) {
-                        // Flush any pending content from the paused run before interacting with resume flows.
-                        if (accumulator.hasPendingContent()) {
-                            const pausedMessages = accumulator.flush();
-                            const sid = sessionIdRef.current;
-                            if (sessionHistory && sid) {
-                                sessionHistory.persistMessagesNonBlocking(sid, pausedMessages);
-                            }
-                            // Already not streaming (DISCARD_STREAMING above), so append as committed
-                            setMessages((prev) => [...prev, ...pausedMessages]);
-                            // Only reload from SQLite when no snapshot set sessionMessagesRef —
-                            // the snapshot already has the complete model-level conversation.
-                            if (!hasSnapshot && sid)
-                                refreshSessionMessagesFromStorage(sid);
-                        }
-                        await continuePausedRun({
-                            pendingInteraction,
-                            ...(respondingArion?.name ? { respondingArionName: respondingArion.name } : {}),
-                            startedAt: startTime,
-                            abortSignal,
-                        });
-                    }
-                    else {
-                        if (!finalRunResult.ok) {
-                            throw Object.assign(new Error(finalRunResult.error.message), {
-                                ...(finalRunResult.error.details === undefined
-                                    ? {}
-                                    : { diagnostic: finalRunResult.error.details }),
-                            });
-                        }
-                        // Flush any remaining content (e.g., final turn without turn_complete)
-                        if (accumulator.hasPendingContent()) {
-                            const remaining = accumulator.flush();
-                            const sid = sessionIdRef.current;
-                            if (sessionHistory && sid) {
-                                sessionHistory.persistMessagesNonBlocking(sid, remaining);
-                            }
-                            // Already not streaming (DISCARD_STREAMING above), so append as committed
-                            setMessages((prev) => [...prev, ...remaining]);
-                            // Only reload from SQLite when no snapshot set sessionMessagesRef —
-                            // the snapshot already has the complete model-level conversation.
-                            if (!hasSnapshot && sid)
-                                refreshSessionMessagesFromStorage(sid);
-                        }
-                        appendAssistantConversationHistory(sessionMessagesRef.current, respondingArion?.name);
-                        // Fire-and-forget: post-turn bookkeeping must NEVER block returning to the prompt.
-                        // These update memory counts and arion lists — background state the user doesn't
-                        // need before typing their next message. Awaiting them was the root cause of
-                        // the end-of-turn freeze: async DB calls blocked handleSubmit, which blocked
-                        // the React render cycle, which blocked Ink's stdout.write, which blocked stdin.
-                        void getCurrentMemoria()
-                            .then((m) => m.count())
-                            .then((count) => setMemoryCount(count))
-                            .catch((err) => log.warn("Memory finalization failed:", err));
-                        void refreshArionsList().catch((err) => log.warn("Arion list refresh failed:", err));
-                    }
-                } // end if (!abortSignal.aborted)
-            }
-            catch (error) {
-                logInternalRunFailure(error);
-                // Stop render scheduler on error path
-                clearInterval(previewRenderTimer);
-                // Flush any pending content from the accumulator on abort/error path
-                // so partial results are persisted and visible to the user.
-                try {
-                    if (accumulator.hasPendingContent()) {
-                        const partial = accumulator.flush();
-                        const sessionId = sessionIdRef.current;
-                        if (sessionHistory && sessionId) {
-                            sessionHistory.persistMessagesNonBlocking(sessionId, partial);
-                            refreshSessionMessagesFromStorage(sessionId);
-                        }
-                        // Atomic: commit partial content and end streaming
-                        msgDispatch({ type: "COMMIT_AND_END", flushed: partial });
-                    }
-                    else {
-                        msgDispatch({ type: "DISCARD_STREAMING" });
-                    }
-                }
-                catch (persistErr) {
-                    log.warn("[InkREPL] Failed to persist messages on error path:", persistErr?.message);
-                }
-                setObsCtx(null);
-                // Stop wall-time timer on error
-                if (wallTimeIntervalRef.current) {
-                    clearInterval(wallTimeIntervalRef.current);
-                    wallTimeIntervalRef.current = null;
-                }
-                isStreamingRef.current = false;
-                // isStreaming already false from COMMIT_AND_END or DISCARD_STREAMING above
-                setSpans([]);
-                setMessages((prev) => [
-                    ...prev,
-                    createErrorMessage(`Error: ${error.message}`),
-                ]);
-            }
-            // Drain queued message (sent while streaming)
-            const queued = queuedMessageRef.current;
-            if (queued) {
-                queuedMessageRef.current = null;
-                setQueuedMessage(null);
-                // Use setTimeout to let React finish the current render cycle
-                setTimeout(() => handleSubmit(queued), 0);
-            }
-        })().catch((err) => {
-            // Safety net: catch any unhandled error from the detached async turn.
-            // All known error paths have their own try/catch inside, but this
-            // prevents unhandled rejections if a new code path is added without one.
-            logInternalRunFailure(err);
-            isStreamingRef.current = false;
-            msgDispatch({ type: "DISCARD_STREAMING" });
-            setMessages((prev) => [...prev, createErrorMessage(`Error: ${err.message}`)]);
-            // Drain queued message — same logic as the normal path.
-            // Without this, messages queued during a fatally-failed turn are silently lost.
-            const queued = queuedMessageRef.current;
-            if (queued) {
-                queuedMessageRef.current = null;
-                setQueuedMessage(null);
-                setTimeout(() => handleSubmit(queued), 0);
-            }
-        });
-    }, [
-        router,
-        session,
-        manager,
-        userName,
-        refreshArionsList,
-        aria,
-        getCurrentMemoria,
-        appendAssistantConversationHistory,
-        bindMemoriaSession,
-        continuePausedRun,
-        headlessRunKernel,
-        publishResumeMarker,
-        logInternalRunFailure,
-        model,
-        respondToHeadlessRunInteraction,
-        sessionHistory,
-        refreshSessionMessagesFromStorage,
-        authResolver,
-        waitForLocalControlReady,
-    ]);
-    // Stable ref so the inbox subscription can call handleSubmit without stale closures.
-    const handleSubmitRef = useRef(handleSubmit);
-    handleSubmitRef.current = handleSubmit;
-    // Auto-restore session on first render (from -r / -c CLI flags).
-    // Must fire BEFORE initialMessage so crash resume loads history first.
-    useEffect(() => {
-        const requestedResume = resumeSessionId || getPendingResumeSessionId();
-        if (!requestedResume) {
-            resumeRestoreReadyRef.current = Promise.resolve();
-            return;
-        }
-        if (requestedResume && !resumeSessionFired.current) {
-            resumeSessionFired.current = true;
-            resumeRestoreReadyRef.current = handleSelectSession(requestedResume);
-        }
-    }, [resumeSessionId, handleSelectSession]);
-    // Auto-submit initialMessage on first render (CLI arg support).
-    // Fires AFTER session resume so crash recovery loads history first.
-    useEffect(() => {
-        if (!initialMessage || initialMessageFired.current)
-            return;
-        let cancelled = false;
-        const submitInitialMessage = async () => {
-            const resumeRequested = resumeSessionId || getPendingResumeSessionId();
-            if (resumeRequested) {
-                await resumeRestoreReadyRef.current;
-            }
-            if (cancelled || initialMessageFired.current) {
-                return;
-            }
-            initialMessageFired.current = true;
-            await handleSubmit(initialMessage);
-        };
-        void submitInitialMessage();
-        return () => {
-            cancelled = true;
-        };
-    }, [initialMessage, handleSubmit, resumeSessionId]);
-    const handleCancel = useCallback(() => {
-        if (abortController.current) {
-            abortController.current.abort();
-            abortController.current = null;
-            isStreamingRef.current = false;
-            msgDispatch({ type: "DISCARD_STREAMING" });
-            // Stop wall-time timer on cancel
-            if (wallTimeIntervalRef.current) {
-                clearInterval(wallTimeIntervalRef.current);
-                wallTimeIntervalRef.current = null;
-            }
-        }
-    }, []);
-    // Cancel a queued message and move its text back to the input box for editing.
-    // Called when user presses Escape during streaming while a queued message is displayed.
-    // "undo last message" UX: the message is not sent,
-    // its text is placed in the input, and the user can edit and re-submit.
-    const handleCancelQueuedMessage = useCallback(() => {
-        const text = queuedMessageRef.current;
-        if (!text)
-            return;
-        queuedMessageRef.current = null;
-        setQueuedMessage(null);
-        setPrefillInput(text);
-    }, []);
-    const handleCycleDisplayMode = useCallback(() => {
-        setDisplayMode((prevMode) => {
-            const nextMode = nextDisplayMode(prevMode);
-            setDisplayConfig((prevConfig) => {
-                const overrides = deriveDisplayOverrides(prevMode, prevConfig);
-                return resolveDisplayConfig(nextMode, overrides);
-            });
-            return nextMode;
-        });
-    }, []);
-    const handleToggleThinking = useCallback(() => {
-        setDisplayConfig((prev) => ({ ...prev, showThinking: !prev.showThinking }));
-    }, []);
-    const handleToggleCosts = useCallback(() => {
-        setDisplayConfig((prev) => ({ ...prev, showCosts: !prev.showCosts }));
-    }, []);
-    const handleToggleTraces = useCallback(() => {
-        setDisplayConfig((prev) => ({ ...prev, showTraces: !prev.showTraces }));
-    }, []);
-    const handleCommand = useCallback(async (cmd, _args) => {
-        switch (cmd) {
-            case "help": {
-                const helpText = COMMANDS.map((c) => `/${c.name} - ${c.description}`).join("\n");
-                setMessages((prev) => [...prev, createSystemMessage(helpText)]);
-                break;
-            }
-            case "arions": {
-                try {
-                    const { resultFrame } = await dispatchHeadlessCommand("arion.list", {});
-                    if (!resultFrame) {
-                        throw new Error("arion.list produced no result frame");
-                    }
-                    if (!resultFrame.ok) {
-                        throw new Error(resultFrame.error.message);
-                    }
-                    const list = resultFrame.result.arions ?? [];
-                    const arionText = list.map((a) => `${a.emoji} ${a.name} (${a.status})`).join("\n");
-                    setMessages((prev) => [...prev, createSystemMessage(arionText || "No arions found")]);
-                }
-                catch (error) {
-                    setMessages((prev) => [
-                        ...prev,
-                        createErrorMessage(`Failed to list arions: ${error.message}`),
-                    ]);
-                }
-                break;
-            }
-            case "sound": {
-                const arg = _args?.trim().toLowerCase();
-                if (arg === "on" || arg === "off") {
-                    // Quick inline toggle still works for scripting/power users
-                    const on = arg === "on";
-                    sounds.setEnabled(on);
-                    const cfg = loadConfig();
-                    cfg.soundEnabled = on;
-                    saveConfig(cfg);
-                    setMessages((prev) => [
-                        ...prev,
-                        createSystemMessage(`Sound notifications ${on ? "enabled 🔊" : "disabled 🔇"}.`),
-                    ]);
-                }
-                else {
-                    // Open the polished sound overlay
-                    setOpenSoundOverlaySignal((prev) => (prev ?? 0) + 1);
-                }
-                break;
-            }
-            case "exit": {
-                // Use Ink's exit() instead of process.exit(0) so the graceful
-                // shutdown path in startInkRepl runs (markCompleted, endSession).
-                exit();
-                break;
-            }
-            case "hatch": {
-                const hatchName = _args?.trim();
-                if (!hatchName) {
-                    setMessages((prev) => [
-                        ...prev,
-                        createSystemMessage("Usage: /hatch <name> [description]\nExample: /hatch Luna a dreamy, creative assistant\n\nDescribe the arion you want to create and ARIA will help design and hatch them."),
-                    ]);
-                    break;
-                }
-                try {
-                    const parts = hatchName.split(/\s+/);
-                    const name = parts[0];
-                    const description = parts.slice(1).join(" ");
-                    const { resultFrame } = await dispatchHeadlessCommand("arion.hatch", {
-                        name,
-                        ...(description ? { description } : {}),
-                    });
-                    if (!resultFrame) {
-                        throw new Error("arion.hatch produced no result frame");
-                    }
-                    if (!resultFrame.ok) {
-                        throw new Error(resultFrame.error.message);
-                    }
-                    const prompt = resultFrame.result.prompt;
-                    if (!prompt) {
-                        throw new Error("arion.hatch did not return a prompt");
-                    }
-                    await handleSubmit(prompt);
-                }
-                catch (error) {
-                    setMessages((prev) => [
-                        ...prev,
-                        createErrorMessage(`Error: ${error.message}`),
-                    ]);
-                }
-                break;
-            }
-            case "remember": {
-                try {
-                    const { resultFrame } = await dispatchHeadlessCommand("memory.remember", {
-                        text: _args ?? "",
-                    });
-                    if (!resultFrame) {
-                        throw new Error("memory.remember produced no result frame");
-                    }
-                    if (!resultFrame.ok) {
-                        throw new Error(resultFrame.error.message);
-                    }
-                    const result = resultFrame.result;
-                    setMessages((prev) => [
-                        ...prev,
-                        createSystemMessage(String(result.message ?? "Memory saved.")),
-                    ]);
-                    const count = result.data?.count;
-                    if (typeof count === "number") {
-                        setMemoryCount(count);
-                    }
-                }
-                catch (error) {
-                    setMessages((prev) => [
-                        ...prev,
-                        createErrorMessage(`Error remembering: ${error.message}`),
-                    ]);
-                }
-                break;
-            }
-            case "recall": {
-                try {
-                    const { resultFrame } = await dispatchHeadlessCommand("memory.recall", {
-                        query: _args ?? "",
-                    });
-                    if (!resultFrame) {
-                        throw new Error("memory.recall produced no result frame");
-                    }
-                    if (!resultFrame.ok) {
-                        throw new Error(resultFrame.error.message);
-                    }
-                    const result = resultFrame.result;
-                    const recalled = result.memories;
-                    let content = String(result.message ?? "No memories found.");
-                    if (Array.isArray(recalled) && recalled.length > 0) {
-                        const resultText = recalled
-                            .map((raw, i) => {
-                            const item = raw;
-                            const text = typeof item.content === "string" ? item.content : String(raw);
-                            const preview = text.length > 80 ? text.slice(0, 80) + "..." : text;
-                            const score = typeof item.confidence === "number"
-                                ? `(${Math.round(item.confidence * 100)}%) `
-                                : "";
-                            const createdAt = item.createdAt instanceof Date
-                                ? item.createdAt.toISOString().slice(0, 10)
-                                : String(item.createdAt ?? "").slice(0, 10);
-                            const idText = typeof item.id === "string" ? item.id.slice(0, 8) : "unknown";
-                            const network = typeof item.network === "string" && item.network.trim().length > 0
-                                ? item.network
-                                : "default";
-                            return `[${i + 1}] ${score}${preview} [${network}] ${createdAt} (${idText})`;
-                        })
-                            .join("\n");
-                        content = `Found ${recalled.length} memories:\n${resultText}`;
-                    }
-                    setMessages((prev) => [...prev, createSystemMessage(content)]);
-                }
-                catch (error) {
-                    setMessages((prev) => [
-                        ...prev,
-                        createErrorMessage(`Error recalling: ${error.message}`),
-                    ]);
-                }
-                break;
-            }
-            case "recall_knowledge": {
-                if (_args?.trim()) {
-                    try {
-                        const { resultFrame } = await dispatchHeadlessCommand("memory.recall_knowledge", {
-                            topic: _args.trim(),
-                            limit: 5,
-                        });
-                        if (!resultFrame) {
-                            throw new Error("memory.recall_knowledge produced no result frame");
-                        }
-                        if (!resultFrame.ok) {
-                            throw new Error(resultFrame.error.message);
-                        }
-                        const result = resultFrame.result;
-                        const results = Array.isArray(result.tools) ? result.tools : [];
-                        if (results.length === 0) {
-                            setMessages((prev) => [
-                                ...prev,
-                                createSystemMessage(`No tools found for: "${_args.trim()}"`),
-                            ]);
-                        }
-                        else {
-                            const resultText = results
-                                .map((k, i) => {
-                                const desc = k.description.length > 80
-                                    ? k.description.slice(0, 80) + "..."
-                                    : k.description;
-                                return `[${i + 1}] ${k.name} - ${desc}`;
-                            })
-                                .join("\n");
-                            setMessages((prev) => [
-                                ...prev,
-                                createSystemMessage(`Found ${results.length} tool items:\n${resultText}`),
-                            ]);
-                        }
-                    }
-                    catch (error) {
-                        setMessages((prev) => [
-                            ...prev,
-                            createErrorMessage(`Error recalling tools: ${error.message}`),
-                        ]);
-                    }
-                }
-                else {
-                    setMessages((prev) => [
-                        ...prev,
-                        createSystemMessage("Usage: /recall_knowledge <topic>\nSearches stored tools (skills, procedures, techniques) by topic."),
-                    ]);
-                }
-                break;
-            }
-            case "send": {
-                try {
-                    const senderName = session.getPrimary()?.name ?? "ARIA";
-                    const { resultFrame } = await dispatchHeadlessCommand("message.send", {
-                        args: _args ?? "",
-                        senderName,
-                    });
-                    if (!resultFrame) {
-                        throw new Error("message.send produced no result frame");
-                    }
-                    const result = resultFrame.ok
-                        ? resultFrame.result
-                        : { message: resultFrame.error.message };
-                    setMessages((prev) => [
-                        ...prev,
-                        resultFrame.ok
-                            ? createSystemMessage(result.message ?? "Message sent.")
-                            : createErrorMessage(result.message ?? "Failed to send message."),
-                    ]);
-                }
-                catch (error) {
-                    setMessages((prev) => [
-                        ...prev,
-                        createErrorMessage(`Failed to send peer message: ${error.message}`),
-                    ]);
-                }
-                break;
-            }
-            case "clear": {
-                // Block clear while streaming to prevent data corruption (R2-C2 fix)
-                if (isStreamingRef.current)
-                    break;
-                const existingSessionId = sessionIdRef.current;
-                if (existingSessionId) {
-                    await endMemoriaSession(existingSessionId);
-                }
-                session.clearHistory();
-                sessionMessagesRef.current = [];
-                sessionIdRef.current = null;
-                setPendingResumeSessionId(null);
-                _shutdownState.sessionId = null;
-                // Close JSONL logger so next submit creates a fresh one for the new session
-                if (_shutdownState.jsonlLogger) {
-                    void _shutdownState.jsonlLogger.close().catch((err) => {
-                        log.warn("[InkREPL] JSONL logger close failed:", err?.message ?? err);
-                    });
-                    _shutdownState.jsonlLogger = null;
-                }
-                setSpans([]);
-                setPipelineTiming(undefined);
-                // Clear the terminal screen — Ink's <Static> can't remove already-rendered
-                // items from scrollback, so we clear the terminal directly.
-                process.stdout.write("\x1b[2J\x1b[H");
-                resetStaticRenderer();
-                setMessages([createSystemMessage("Conversation cleared.")]);
-                break;
-            }
-            case "resume": {
-                if (_args?.trim()) {
-                    await handleSelectSession(_args.trim());
-                }
-                else {
-                    setOpenSessionOverlaySignal((n) => (n ?? 0) + 1);
-                }
-                break;
-            }
-            case "fork": {
-                // Block fork while streaming to prevent data corruption (R2-C2 pattern)
-                if (isStreamingRef.current)
-                    break;
-                const forkParts = _args?.trim().split(/\s+/).filter(Boolean) ?? [];
-                const forkStay = forkParts.includes("--stay");
-                const forkFiltered = forkParts.filter((p) => p !== "--stay");
-                let forkSourceId = sessionIdRef.current;
-                let forkMessageLimit;
-                // Parse args: /fork, /fork <n>, /fork <id>, /fork <id> <n>
-                if (forkFiltered.length === 1 && /^\d+$/.test(forkFiltered[0])) {
-                    forkMessageLimit = parseInt(forkFiltered[0], 10);
-                }
-                else if (forkFiltered.length >= 1 && forkFiltered[0]) {
-                    forkSourceId = forkFiltered[0];
-                    if (forkFiltered[1] && /^\d+$/.test(forkFiltered[1])) {
-                        forkMessageLimit = parseInt(forkFiltered[1], 10);
-                    }
-                }
-                if (!forkSourceId) {
-                    setMessages((prev) => [
-                        ...prev,
-                        createSystemMessage("No active session to fork. Start a conversation first or specify a session ID: /fork <session-id>"),
-                    ]);
-                    break;
-                }
-                try {
-                    const { resultFrame } = await dispatchHeadlessCommand("session.fork", {
-                        sessionId: forkSourceId,
-                        ...(forkMessageLimit !== undefined ? { messageLimit: forkMessageLimit } : {}),
-                    });
-                    if (!resultFrame) {
-                        throw new Error("session.fork produced no result frame");
-                    }
-                    if (!resultFrame.ok) {
-                        throw new Error(resultFrame.error.message);
-                    }
-                    const forkResult = resultFrame.result;
-                    if (forkStay) {
-                        setMessages((prev) => [
-                            ...prev,
-                            createSystemMessage(`🍴 Forked → ${forkResult.newSessionId.slice(0, 8)} (${forkResult.messagesCopied} msgs). Resume it later with /resume ${forkResult.newSessionId.slice(0, 8)}`),
-                        ]);
-                    }
-                    else {
-                        setMessages((prev) => [
-                            ...prev,
-                            createSystemMessage(`🍴 Forked ${forkResult.sourceSessionId.slice(0, 8)}→${forkResult.newSessionId.slice(0, 8)} (${forkResult.messagesCopied} msgs)`),
-                        ]);
-                        await handleSelectSession(forkResult.newSessionId);
-                    }
-                }
-                catch (error) {
-                    setMessages((prev) => [
-                        ...prev,
-                        createErrorMessage(`Fork failed: ${error.message}`),
-                    ]);
-                }
-                break;
-            }
-            case "rest": {
-                const restName = _args?.trim();
-                if (!restName) {
-                    setMessages((prev) => [...prev, createSystemMessage("Usage: /rest <arion-name>")]);
-                    break;
-                }
-                try {
-                    const { resultFrame } = await dispatchHeadlessCommand("arion.rest", { name: restName });
-                    if (!resultFrame) {
-                        throw new Error("arion.rest produced no result frame");
-                    }
-                    if (!resultFrame.ok) {
-                        throw new Error(resultFrame.error.message);
-                    }
-                    setMessages((prev) => [...prev, createSystemMessage(`${restName} is now resting.`)]);
-                    await refreshArionsList();
-                }
-                catch (e) {
-                    setMessages((prev) => [
-                        ...prev,
-                        createErrorMessage(`Cannot rest ${restName}: ${e.message}`),
-                    ]);
-                }
-                break;
-            }
-            case "wake": {
-                const wakeName = _args?.trim();
-                if (!wakeName) {
-                    setMessages((prev) => [...prev, createSystemMessage("Usage: /wake <arion-name>")]);
-                    break;
-                }
-                try {
-                    const { resultFrame } = await dispatchHeadlessCommand("arion.wake", { name: wakeName });
-                    if (!resultFrame) {
-                        throw new Error("arion.wake produced no result frame");
-                    }
-                    if (!resultFrame.ok) {
-                        throw new Error(resultFrame.error.message);
-                    }
-                    setMessages((prev) => [...prev, createSystemMessage(`${wakeName} is now awake.`)]);
-                    await refreshArionsList();
-                }
-                catch (e) {
-                    setMessages((prev) => [
-                        ...prev,
-                        createErrorMessage(`Cannot wake ${wakeName}: ${e.message}`),
-                    ]);
-                }
-                break;
-            }
-            case "become": {
-                const becomeName = _args?.trim();
-                if (!becomeName) {
-                    setMessages((prev) => [...prev, createSystemMessage("Usage: /become <arion-name>")]);
-                    break;
-                }
-                try {
-                    const { resultFrame } = await dispatchHeadlessCommand("arion.become", {
-                        name: becomeName,
-                    });
-                    if (!resultFrame) {
-                        throw new Error("arion.become produced no result frame");
-                    }
-                    if (!resultFrame.ok) {
-                        throw new Error(resultFrame.error.message);
-                    }
-                    const arion = resultFrame.result.arion;
-                    if (!arion) {
-                        throw new Error(`Arion ${becomeName} not found`);
-                    }
-                    const config = loadConfig();
-                    const becomeTier = config.preferredTier || "balanced";
-                    const becomeTierModel = getDefaultModelByTier(becomeTier, credentialHints);
-                    const becomeModel = arion.preferredModel || becomeTierModel?.shortName || initialModel;
-                    activeArionRef.current = arion.name;
-                    setActiveArion(arion.name);
-                    setModel(becomeModel);
-                    modelRef.current = becomeModel;
-                    // RunSession is now per-submit — no need to recreate here
-                    setMessages((prev) => [
-                        ...prev,
-                        createSystemMessage(`Switched to ${arion.name} (model: ${becomeModel})`),
-                    ]);
-                    const memoria = await getCurrentMemoria();
-                    const count = await memoria.count();
-                    setMemoryCount(count);
-                    await refreshArionsList();
-                }
-                catch (e) {
-                    setMessages((prev) => [
-                        ...prev,
-                        createErrorMessage(`Cannot become ${becomeName}: ${e.message}`),
-                    ]);
-                }
-                break;
-            }
-            case "model": {
-                const modelArg = _args?.trim() || "";
-                const providerMatches = [...modelArg.matchAll(/--provider\s+([^\s]+)/gi)]
-                    .map((match) => match[1]?.trim())
-                    .filter(Boolean);
-                const useEnv = /--use-env\b/i.test(modelArg);
-                const sanitizedModelArg = modelArg
-                    .replace(/--provider\s+([^\s]+)/gi, "")
-                    .replace(/--use-env\b/gi, "")
-                    .trim();
-                const normalizedModelArg = sanitizedModelArg.toLowerCase();
-                if (normalizedModelArg === "refresh") {
-                    setMessages((prev) => [
-                        ...prev,
-                        createSystemMessage(useEnv
-                            ? "Importing env credentials and discovering models..."
-                            : "Discovering models from all providers..."),
-                    ]);
-                    try {
-                        if (useEnv) {
-                            await dispatchHeadlessCommand("auth.import_env_session", {
-                                ...(providerMatches.length ? { providers: providerMatches } : {}),
-                            });
-                        }
-                        const { resultFrame } = await dispatchHeadlessCommand("model.refresh", providerMatches.length ? { providers: providerMatches } : {});
-                        if (!resultFrame) {
-                            throw new Error("model.refresh produced no result frame");
-                        }
-                        if (!resultFrame.ok) {
-                            throw new Error(resultFrame.error.message);
-                        }
-                        const discovered = resultFrame.result.models ??
-                            availableModels;
-                        const refreshedSelectable = getCliSelectableModels(discovered);
-                        setMessages((prev) => [
-                            ...prev,
-                            createSystemMessage(`Updated model catalog (${refreshedSelectable.length} selectable models)`),
-                        ]);
-                    }
-                    catch (err) {
-                        setMessages((prev) => [
-                            ...prev,
-                            createErrorMessage(`Discovery failed: ${err.message}`),
-                        ]);
-                    }
-                    finally {
-                        if (useEnv) {
-                            await dispatchHeadlessCommand("auth.clear_session", {}).catch(() => { });
-                        }
-                    }
-                    break;
-                }
-                if (!normalizedModelArg || normalizedModelArg === "list") {
-                    try {
-                        const { resultFrame } = await dispatchHeadlessCommand("model.list", providerMatches.length ? { providers: providerMatches } : {});
-                        if (!resultFrame) {
-                            throw new Error("model.list produced no result frame");
-                        }
-                        if (!resultFrame.ok) {
-                            throw new Error(resultFrame.error.message);
-                        }
-                        const listedModels = resultFrame.result.models ?? availableModels;
-                        const currentModel = resultFrame.result.currentModel ?? model;
-                        const listedSelectable = getCliSelectableModels(listedModels);
-                        const modelList = listedSelectable
-                            .map((m) => `  ${m.shortName.toLowerCase() === currentModel.toLowerCase() ? "\u2192 " : "  "}${m.provider}/${m.shortName} (${m.tier})`)
-                            .join("\n");
-                        setMessages((prev) => [
-                            ...prev,
-                            createSystemMessage(`Current model: ${currentModel}\n\nAvailable models:\n${modelList}\n\nUse /model <name> or /model <provider>/<name> to switch.`),
-                        ]);
-                    }
-                    catch (error) {
-                        setMessages((prev) => [
-                            ...prev,
-                            createErrorMessage(`Model listing failed: ${error.message}`),
-                        ]);
-                    }
-                }
-                else {
-                    try {
-                        const { resultFrame } = await dispatchHeadlessCommand("model.set", {
-                            model: sanitizedModelArg,
-                        });
-                        if (!resultFrame) {
-                            throw new Error("model.set produced no result frame");
-                        }
-                        if (!resultFrame.ok) {
-                            throw new Error(resultFrame.error.message);
-                        }
-                        const currentModel = resultFrame.result.currentModel ?? sanitizedModelArg;
-                        setModel(currentModel);
-                        modelRef.current = currentModel;
-                        setMessages((prev) => [
-                            ...prev,
-                            createSystemMessage(`Switched model to ${currentModel}`),
-                        ]);
-                    }
-                    catch (error) {
-                        setMessages((prev) => [
-                            ...prev,
-                            createErrorMessage(`Unknown model: ${modelArg}. Use /model list to see available models. ${error.message}`),
-                        ]);
-                    }
-                }
-                break;
-            }
-            case "auth": {
-                const authArgs = _args?.trim() || "";
-                const [subcommand, ...rest] = authArgs.length > 0 ? authArgs.split(/\s+/) : [];
-                const normalizedSubcommand = (subcommand ?? "").toLowerCase();
-                if (normalizedSubcommand === "import-env") {
-                    try {
-                        const providers = rest.filter((value) => value.trim().length > 0);
-                        const { resultFrame } = await dispatchHeadlessCommand("auth.import_env_session", {
-                            ...(providers.length ? { providers } : {}),
-                        });
-                        if (!resultFrame) {
-                            throw new Error("auth.import_env_session produced no result frame");
-                        }
-                        if (!resultFrame.ok) {
-                            throw new Error(resultFrame.error.message);
-                        }
-                        const imported = (resultFrame.result.providers ??
-                            []);
-                        setMessages((prev) => [
-                            ...prev,
-                            createSystemMessage(imported.length > 0
-                                ? `Imported session credentials for: ${imported.join(", ")}`
-                                : "No matching env credentials found to import into session scope."),
-                        ]);
-                    }
-                    catch (error) {
-                        setMessages((prev) => [
-                            ...prev,
-                            createErrorMessage(`Auth import failed: ${error.message}`),
-                        ]);
-                    }
-                    break;
-                }
-                if (normalizedSubcommand === "clear-session") {
-                    try {
-                        const { resultFrame } = await dispatchHeadlessCommand("auth.clear_session", {});
-                        if (!resultFrame) {
-                            throw new Error("auth.clear_session produced no result frame");
-                        }
-                        if (!resultFrame.ok) {
-                            throw new Error(resultFrame.error.message);
-                        }
-                        setMessages((prev) => [
-                            ...prev,
-                            createSystemMessage("Cleared session credential overlay."),
-                        ]);
-                    }
-                    catch (error) {
-                        setMessages((prev) => [
-                            ...prev,
-                            createErrorMessage(`Auth clear failed: ${error.message}`),
-                        ]);
-                    }
-                    break;
-                }
-                if (normalizedSubcommand === "status-session") {
-                    try {
-                        const { resultFrame } = await dispatchHeadlessCommand("auth.status", {});
-                        if (!resultFrame) {
-                            throw new Error("auth.status produced no result frame");
-                        }
-                        if (!resultFrame.ok) {
-                            throw new Error(resultFrame.error.message);
-                        }
-                        const providers = (resultFrame.result
-                            .sessionProviders ?? []);
-                        setMessages((prev) => [
-                            ...prev,
-                            createSystemMessage(providers.length > 0
-                                ? `Session credential overlay providers: ${providers.join(", ")}`
-                                : "No session credential overlay providers are currently set."),
-                        ]);
-                    }
-                    catch (error) {
-                        setMessages((prev) => [
-                            ...prev,
-                            createErrorMessage(`Auth status failed: ${error.message}`),
-                        ]);
-                    }
-                    break;
-                }
-                setMessages((prev) => [
-                    ...prev,
-                    createSystemMessage("Usage: /auth import-env [provider ...] | /auth clear-session | /auth status-session"),
-                ]);
-                break;
-            }
-            case "autonomy": {
-                if (_args && _args.trim()) {
-                    try {
-                        const level = _args.trim().toLowerCase();
-                        const { resultFrame } = await dispatchHeadlessCommand("config.autonomy.set", {
-                            autonomy: level,
-                        });
-                        if (!resultFrame) {
-                            throw new Error("config.autonomy.set produced no result frame");
-                        }
-                        if (!resultFrame.ok) {
-                            throw new Error(resultFrame.error.message);
-                        }
-                        setMessages((prev) => [
-                            ...prev,
-                            createSystemMessage(`Autonomy level set to: ${level}`),
-                        ]);
-                    }
-                    catch (error) {
-                        setMessages((prev) => [
-                            ...prev,
-                            createErrorMessage(`Invalid autonomy level: ${_args.trim().toLowerCase()}. ${error.message}`),
-                        ]);
-                    }
-                }
-                else {
-                    // No args — show interactive selector
-                    setShowAutonomySelector(true);
-                }
-                break;
-            }
-            case "memories": {
-                try {
-                    const { resultFrame } = await dispatchHeadlessCommand("memory.list", {
-                        limit: 20,
-                    });
-                    if (!resultFrame) {
-                        throw new Error("memory.list produced no result frame");
-                    }
-                    if (!resultFrame.ok) {
-                        throw new Error(resultFrame.error.message);
-                    }
-                    const result = resultFrame.result;
-                    const count = typeof result.count === "number" ? result.count : 0;
-                    if (count === 0) {
-                        setMessages((prev) => [
-                            ...prev,
-                            createSystemMessage("No memories stored. Use /remember to store memories."),
-                        ]);
-                    }
-                    else {
-                        const memories = Array.isArray(result.memories) ? result.memories : [];
-                        const memoryList = memories
-                            .map((m) => `  [${m.id.slice(0, 8)}] ${m.content.slice(0, 80)}${m.content.length > 80 ? "..." : ""}`)
-                            .join("\n");
-                        setMessages((prev) => [
-                            ...prev,
-                            createSystemMessage(`Memories (${count} total):\n${memoryList}`),
-                        ]);
-                    }
-                }
-                catch (e) {
-                    setMessages((prev) => [
-                        ...prev,
-                        createErrorMessage(`Failed to list memories: ${e.message}`),
-                    ]);
-                }
-                break;
-            }
-            case "forget": {
-                try {
-                    const { resultFrame } = await dispatchHeadlessCommand("memory.forget", {
-                        id: _args ?? "",
-                    });
-                    if (!resultFrame) {
-                        throw new Error("memory.forget produced no result frame");
-                    }
-                    if (!resultFrame.ok) {
-                        throw new Error(resultFrame.error.message);
-                    }
-                    const result = resultFrame.result;
-                    setMessages((prev) => [
-                        ...prev,
-                        createSystemMessage(String(result.message ?? "Memory deleted.")),
-                    ]);
-                    if (typeof result.count === "number") {
-                        setMemoryCount(result.count);
-                    }
-                }
-                catch (e) {
-                    setMessages((prev) => [
-                        ...prev,
-                        createErrorMessage(`Failed to delete memory: ${e.message}`),
-                    ]);
-                }
-                break;
-            }
-            case "daemon": {
-                const action = (_args ?? "").trim().toLowerCase();
-                if (action === "start" || action === "stop" || action === "restart") {
-                    await handleDaemonAction(action);
-                    break;
-                }
-                if (action.length > 0) {
-                    setMessages((prev) => [
-                        ...prev,
-                        createSystemMessage("Usage: /daemon [start|stop|restart]"),
-                    ]);
-                    break;
-                }
-                void (async () => {
-                    await refreshDaemonStatus();
-                    setDaemonActionStatus(null);
-                    setOpenDaemonOverlaySignal((prev) => (prev ?? 0) + 1);
-                })();
-                break;
-            }
-            case "terminal-setup": {
-                try {
-                    const { resultFrame } = await dispatchHeadlessCommand("system.terminal_setup", {});
-                    if (!resultFrame) {
-                        throw new Error("system.terminal_setup produced no result frame");
-                    }
-                    if (!resultFrame.ok) {
-                        throw new Error(resultFrame.error.message);
-                    }
-                    const result = resultFrame.result;
-                    setMessages((prev) => [
-                        ...prev,
-                        createSystemMessage(result.supported === false
-                            ? (result.message ?? "terminal-setup is unavailable.")
-                            : (result.output ?? "")),
-                    ]);
-                }
-                catch (error) {
-                    setMessages((prev) => [
-                        ...prev,
-                        createErrorMessage(`terminal-setup failed: ${error.message}`),
-                    ]);
-                }
-                break;
-            }
-            case "login": {
-                try {
-                    await dispatchAuthCommand("auth.login", _args ?? "");
-                }
-                catch (error) {
-                    setMessages((prev) => [
-                        ...prev,
-                        createErrorMessage(`Login failed: ${error.message}`),
-                    ]);
-                }
-                break;
-            }
-            case "logout": {
-                try {
-                    await dispatchAuthCommand("auth.logout", _args ?? "");
-                }
-                catch (error) {
-                    setMessages((prev) => [
-                        ...prev,
-                        createErrorMessage(`Logout failed: ${error.message}`),
-                    ]);
-                }
-                break;
-            }
-            case "theme": {
-                const themeArg = (_args ?? "").trim().toLowerCase();
-                if (!themeArg) {
-                    // No argument: open interactive theme selector overlay
-                    setOpenThemeOverlaySignal((n) => (n ?? 0) + 1);
-                    break;
-                }
-                try {
-                    const { resultFrame } = await dispatchHeadlessCommand("config.theme.set", {
-                        theme: themeArg,
-                    });
-                    if (!resultFrame) {
-                        throw new Error("config.theme.set produced no result frame");
-                    }
-                    if (!resultFrame.ok) {
-                        throw new Error(resultFrame.error.message);
-                    }
-                    setMessages((prev) => [
-                        ...prev,
-                        createSystemMessage(`Theme changed to ${getThemeDefinition(themeArg)?.displayName ?? themeArg} (${themeArg})`),
-                    ]);
-                }
-                catch (error) {
-                    const available = getAvailableThemes();
-                    setMessages((prev) => [
-                        ...prev,
-                        createErrorMessage(`Unknown theme "${themeArg}". Available: ${available.join(", ")}. ${error.message}`),
-                    ]);
-                }
-                break;
-            }
-            case "invite": {
-                await handleCreateInvite(_args?.trim());
-                break;
-            }
-            case "join": {
-                const inviteToken = _args?.trim();
-                if (inviteToken) {
-                    await handleJoinInviteToken(inviteToken);
-                }
-                else {
-                    setJoinInviteError(null);
-                    setOpenJoinInviteOverlaySignal((n) => (n ?? 0) + 1);
-                }
-                break;
-            }
-            case "peers": {
-                setOpenPeersOverlaySignal((n) => (n ?? 0) + 1);
-                break;
-            }
-            case "clients": {
-                setOpenClientsOverlaySignal((n) => (n ?? 0) + 1);
-                break;
-            }
-            default: {
-                setMessages((prev) => [
-                    ...prev,
-                    createSystemMessage(`Unknown command: /${cmd}. Type /help for available commands.`),
-                ]);
-                break;
-            }
-        }
-    }, [
-        manager,
-        router,
-        aria,
-        model,
-        availableModels,
-        selectableModels,
-        credentialHints,
-        dispatchHeadlessCommand,
-        exit,
-        getCurrentMemoria,
-        handleSubmit,
-        handleSelectSession,
-        endMemoriaSession,
-        initialModel,
-        refreshArionsList,
-        session,
-        resetStaticRenderer,
-    ]);
-    handleCommandRef.current = handleCommand;
-    const handleSelectArion = useCallback(async (name, mode) => {
-        if (mode === "mention")
-            return;
-        try {
-            if (mode === "become") {
-                const { resultFrame } = await dispatchHeadlessCommand("arion.become", { name });
-                if (!resultFrame) {
-                    throw new Error("arion.become produced no result frame");
-                }
-                if (!resultFrame.ok) {
-                    throw new Error(resultFrame.error.message);
-                }
-                const arion = resultFrame.result.arion;
-                if (!arion) {
-                    throw new Error(`Arion ${name} not found`);
-                }
-                const config = loadConfig();
-                const tierToUse = config.preferredTier || "balanced";
-                const tierModel = getDefaultModelByTier(tierToUse, credentialHints);
-                const preferredModel = arion.preferredModel
-                    ? getModelByShortName(arion.preferredModel)
-                    : undefined;
-                const effectiveModel = (preferredModel
-                    ? selectRunnableModelVariant(preferredModel, credentialHints).shortName
-                    : undefined) ||
-                    tierModel?.shortName ||
-                    initialModel;
-                setModel(effectiveModel);
-                modelRef.current = effectiveModel;
-                // RunSession is now per-submit — no need to recreate here
-                setMessages((prev) => [
-                    ...prev,
-                    createSystemMessage(`Switched to ${arion.name} (model: ${effectiveModel})`),
-                ]);
-                const memoria = await getCurrentMemoria();
-                const count = await memoria.count();
-                setMemoryCount(count);
-            }
-            else if (mode === "rest") {
-                const { resultFrame } = await dispatchHeadlessCommand("arion.rest", { name });
-                if (!resultFrame) {
-                    throw new Error("arion.rest produced no result frame");
-                }
-                if (!resultFrame.ok) {
-                    throw new Error(resultFrame.error.message);
-                }
-                setMessages((prev) => [...prev, createSystemMessage(`${name} is now resting`)]);
-            }
-            else if (mode === "wake") {
-                const { resultFrame } = await dispatchHeadlessCommand("arion.wake", { name });
-                if (!resultFrame) {
-                    throw new Error("arion.wake produced no result frame");
-                }
-                if (!resultFrame.ok) {
-                    throw new Error(resultFrame.error.message);
-                }
-                setMessages((prev) => [...prev, createSystemMessage(`${name} is now awake`)]);
-            }
-            await refreshArionsList();
-        }
-        catch (error) {
-            setMessages((prev) => [...prev, createErrorMessage(`Error: ${error.message}`)]);
-        }
-    }, [credentialHints, dispatchHeadlessCommand, getCurrentMemoria, initialModel, refreshArionsList]);
-    const handleSelectModel = useCallback(async (name, effort) => {
-        const { resultFrame } = await dispatchHeadlessCommand("model.set", {
-            model: name,
-        });
-        if (!resultFrame) {
-            throw new Error("model.set produced no result frame");
-        }
-        if (!resultFrame.ok) {
-            throw new Error(resultFrame.error.message);
-        }
-        const currentModel = resultFrame.result.currentModel ?? name;
-        setModel(currentModel);
-        modelRef.current = currentModel;
-        if (effort) {
-            setEffortLevel(effort);
-            const cfg = loadConfig();
-            cfg.effortLevel = effort;
-            saveConfig(cfg);
-        }
-        setMessages((prev) => [...prev, createSystemMessage(`Switched to ${currentModel}`)]);
-    }, [dispatchHeadlessCommand]);
-    handleSelectModelRef.current = handleSelectModel;
-    /** Apply theme + persist to config.json. Single source of truth for theme changes. */
-    const handleSelectTheme = useCallback(async (theme) => {
-        try {
-            const { resultFrame } = await dispatchHeadlessCommand("config.theme.set", {
-                theme: theme.name,
-            });
-            if (!resultFrame) {
-                throw new Error("config.theme.set produced no result frame");
-            }
-            if (!resultFrame.ok) {
-                throw new Error(resultFrame.error.message);
-            }
-            setMessages((prev) => [
-                ...prev,
-                createSystemMessage(`Theme changed to ${theme.displayName} (${theme.name})`),
-            ]);
-        }
-        catch (error) {
-            setMessages((prev) => [
-                ...prev,
-                createErrorMessage(`Theme change failed: ${error.message}`),
-            ]);
-        }
-    }, [dispatchHeadlessCommand]);
-    const handleSelectThemeRef = useRef(handleSelectTheme);
-    handleSelectThemeRef.current = handleSelectTheme;
-    const refreshDaemonStatus = useCallback(async () => {
-        try {
-            const { resultFrame } = await dispatchHeadlessCommand("daemon.status", {});
-            if (resultFrame?.ok) {
-                const data = (resultFrame.result ?? {});
-                const loop = (data.autonomousLoop ?? {});
-                setDaemonStatus({
-                    running: true,
-                    port: data.port,
-                    nodeId: data.nodeId,
-                    runtimeId: data.runtimeId,
-                    loopStatus: loop.status,
-                    clients: data.attachedClients,
-                });
-                return true;
-            }
-        }
-        catch {
-            // Status call failed — daemon is unreachable (crashed or stopped).
-        }
-        setDaemonStatus({ running: false });
-        return false;
-    }, [dispatchHeadlessCommand]);
-    /** Handle daemon control actions (start / stop / restart) from the DaemonControl overlay. */
-    const handleDaemonAction = useCallback(async (action) => {
-        const labels = {
-            start: "Starting daemon…",
-            stop: "Stopping daemon…",
-            restart: "Restarting daemon…",
-        };
-        setDaemonActionStatus(labels[action] ?? `${action}…`);
-        try {
-            const command = action === "restart"
-                ? "daemon.restart"
-                : action === "start"
-                    ? "daemon.start"
-                    : "daemon.stop";
-            const { resultFrame } = await dispatchHeadlessCommand(command, {});
-            if (resultFrame && !resultFrame.ok) {
-                throw new Error(resultFrame.error?.message ?? `${action} failed`);
-            }
-            if (action === "stop") {
-                setDaemonStatus({ running: false });
-                setMessages((prev) => [...prev, createSystemMessage("■ Daemon stopped.")]);
-            }
-            else {
-                await refreshDaemonStatus();
-                setMessages((prev) => [
-                    ...prev,
-                    createSystemMessage(action === "restart" ? "↻ Daemon restarted." : "▶ Daemon started."),
-                ]);
-            }
-        }
-        catch (error) {
-            setMessages((prev) => [
-                ...prev,
-                createErrorMessage(`Daemon ${action} failed: ${error.message}`),
-            ]);
-        }
-        finally {
-            setDaemonActionStatus(null);
-        }
-    }, [dispatchHeadlessCommand, refreshDaemonStatus]);
-    // ── Peer pairing handlers ──────────────────────────────────────
-    const handleSelectPeer = useCallback(async (peer) => {
-        // Same-identity peers are auto-connected — no pairing needed
-        if (peer.status === "connected") {
-            try {
-            }
-            catch { }
-            setMessages((prev) => [
-                ...prev,
-                createSystemMessage(`✓ Already connected to ${peer.displayNameSnapshot} (same identity, shared server on port ${peer.port}).`),
-            ]);
-            return;
-        }
-        const isLanPeer = peer.host && isPrivateLanIP(peer.host);
-        const isWanPeer = peer.transport === "wan";
-        // SSRF protection: LAN peers must have private IPs, WAN peers go through relay
-        if (!isWanPeer && peer.host && !isLanPeer) {
-            setMessages((prev) => [
-                ...prev,
-                createErrorMessage(`Rejected: ${peer.host} is not a private LAN address.`),
-            ]);
-            return;
-        }
-        try {
-            if (!peer.principalFingerprint) {
-                throw new Error(`${peer.displayNameSnapshot} did not advertise a principal fingerprint`);
-            }
-            if (!peer.tlsCaFingerprint) {
-                throw new Error(`${peer.displayNameSnapshot} did not advertise a TLS fingerprint`);
-            }
-            if (!peer.host || !peer.port) {
-                throw new Error(`${peer.displayNameSnapshot} did not advertise a control endpoint`);
-            }
-            const { resultFrame } = await dispatchHeadlessCommand("peer.connect", {
-                nodeId: peer.nodeId,
-                displayName: peer.displayNameSnapshot,
-                principalFingerprint: peer.principalFingerprint,
-                controlEndpoint: {
-                    host: peer.host,
-                    port: peer.port,
-                    tlsCaFingerprint: peer.tlsCaFingerprint,
-                    tlsServerIdentity: peer.principalFingerprint,
-                    protocolVersion: 1,
-                },
-                transport: peer.transport,
-            });
-            if (!resultFrame) {
-                throw new Error("peer.connect produced no result frame");
-            }
-            if (!resultFrame.ok) {
-                throw new Error(resultFrame.error.message);
-            }
-            const inviteResult = resultFrame.result.invite;
-            if (!inviteResult) {
-                throw new Error("peer.connect returned no invite payload");
-            }
-            setMessages((prev) => [
-                ...prev,
-                createSystemMessage(inviteResult.mode === "wan_pair"
-                    ? `Paired with ${inviteResult.displayNameSnapshot ?? inviteResult.nodeId}. Awaiting verified ingress before the runtime marks the peer active.`
-                    : `Paired with ${inviteResult.displayNameSnapshot ?? inviteResult.nodeId}. WG tunnel will connect when accepted.`),
-            ]);
-        }
-        catch (error) {
-            setMessages((prev) => [
-                ...prev,
-                createErrorMessage(`Failed to connect to ${peer.displayNameSnapshot}: ${error.message}`),
-            ]);
-        }
-    }, [dispatchHeadlessCommand]);
-    const handleAcceptPairRequest = useCallback(async () => {
-        if (!incomingPairRequest)
-            return;
-        const { id, nodeId, displayNameSnapshot } = incomingPairRequest;
-        const sourceLabel = displayNameSnapshot ?? nodeId;
-        setIncomingPairRequest(null);
-        setMessages((prev) => [
-            ...prev,
-            createSystemMessage(`Accepting connection from ${sourceLabel}...`),
-        ]);
-        try {
-            const { resultFrame } = await dispatchHeadlessCommand("peer.pending.respond", {
-                requestId: id,
-                accepted: true,
-            });
-            if (!resultFrame) {
-                throw new Error("peer.pending.respond produced no result frame");
-            }
-            if (!resultFrame.ok) {
-                throw new Error(resultFrame.error.message);
-            }
-            const data = (resultFrame.result.response ?? {});
-            if (data.error) {
-                throw new Error(data.error);
-            }
-            if (data.accepted) {
-                setMessages((prev) => [
-                    ...prev,
-                    createSystemMessage(`Connected to ${sourceLabel}. Tunnel established.`),
-                ]);
-            }
-        }
-        catch (error) {
-            setMessages((prev) => [
-                ...prev,
-                createErrorMessage(`Failed to accept connection: ${error.message}`),
-            ]);
-        }
-    }, [dispatchHeadlessCommand, incomingPairRequest]);
-    const handleRejectPairRequest = useCallback(() => {
-        if (!incomingPairRequest)
-            return;
-        const { id, nodeId, displayNameSnapshot } = incomingPairRequest;
-        const sourceLabel = displayNameSnapshot ?? nodeId;
-        setIncomingPairRequest(null);
-        setMessages((prev) => [
-            ...prev,
-            createSystemMessage(`Rejected connection from ${sourceLabel}.`),
-        ]);
-        void dispatchHeadlessCommand("peer.pending.respond", {
-            requestId: id,
-            accepted: false,
-        }).catch(() => { });
-    }, [dispatchHeadlessCommand, incomingPairRequest]);
-    const handleCreateInvite = useCallback(async (inviteLabel) => {
-        try {
-            const { resultFrame } = await dispatchHeadlessCommand("peer.invite", {
-                ...(inviteLabel?.trim() ? { inviteLabel: inviteLabel.trim() } : {}),
-            });
-            if (!resultFrame) {
-                throw new Error("peer.invite produced no result frame");
-            }
-            if (!resultFrame.ok) {
-                throw new Error(resultFrame.error.message);
-            }
-            const invite = resultFrame.result.invite;
-            if (!invite) {
-                throw new Error("peer.invite returned no invite payload");
-            }
-            setInviteShare(invite);
-        }
-        catch (error) {
-            setMessages((prev) => [
-                ...prev,
-                createErrorMessage(`Failed to create invite: ${error.message}`),
-            ]);
-        }
-    }, [dispatchHeadlessCommand]);
-    const handleJoinInviteToken = useCallback(async (inviteToken) => {
-        try {
-            const { resultFrame } = await dispatchHeadlessCommand("peer.accept_invite", {
-                inviteToken,
-            });
-            if (!resultFrame) {
-                throw new Error("peer.accept_invite produced no result frame");
-            }
-            if (!resultFrame.ok) {
-                throw new Error(resultFrame.error.message);
-            }
-            const result = resultFrame.result.accepted;
-            if (!result) {
-                throw new Error("peer.accept_invite returned no accepted payload");
-            }
-            setJoinInviteError(null);
-            setMessages((prev) => [
-                ...prev,
-                createSystemMessage(`Paired with ${result.displayNameSnapshot ?? result.nodeId}.`),
-            ]);
-        }
-        catch (error) {
-            const message = `Failed to accept invite: ${error.message}`;
-            setJoinInviteError(message);
-            setMessages((prev) => [...prev, createErrorMessage(message)]);
-        }
-    }, [dispatchHeadlessCommand]);
-    // Poll for incoming pair requests — uses embedded server or external daemon.
-    // Guard: check `active` both before AND after setInterval to prevent leak on unmount.
-    useEffect(() => {
-        let active = true;
-        let interval = null;
-        const startPolling = async () => {
-            const poll = async () => {
-                try {
-                    const { resultFrame } = await dispatchHeadlessCommand("peer.pending.list", {});
-                    if (!active || !resultFrame?.ok)
-                        return; // Server not ready yet — keep polling
-                    const requests = (resultFrame.result.requests ?? []);
-                    if (requests.length && !incomingPairRequest) {
-                        setIncomingPairRequest(requests[0]);
-                    }
-                }
-                catch (err) {
-                    // Server unreachable — will retry next interval
-                    if (isSessionExpiredError(err)) {
-                        if (interval)
-                            clearInterval(interval);
-                        pairPollRef.current = null;
-                        return;
-                    }
-                }
-            };
-            interval = setInterval(poll, 5_000);
-            pairPollRef.current = interval;
-            // Double-check: if unmount happened during local attach resolution, clean up immediately
-            if (!active) {
-                clearInterval(interval);
-                interval = null;
-                pairPollRef.current = null;
-            }
-        };
-        startPolling();
-        return () => {
-            active = false;
-            if (interval)
-                clearInterval(interval);
-            pairPollRef.current = null;
-        };
-    }, [dispatchHeadlessCommand, incomingPairRequest]);
-    const handleOpenMemoryBrowser = useCallback(async (browserMode) => {
-        setMemoryBrowserMode(browserMode);
-        await loadMemories();
-    }, [loadMemories]);
-    const handleSelectMemory = useCallback(async (memory) => {
-        if (memoryBrowserMode === "forget") {
-            try {
-                const { resultFrame } = await dispatchHeadlessCommand("memory.forget", {
-                    id: memory.id,
-                });
-                if (!resultFrame) {
-                    throw new Error("memory.forget produced no result frame");
-                }
-                if (!resultFrame.ok) {
-                    throw new Error(resultFrame.error.message);
-                }
-                const preview = memory.content.length > 50 ? memory.content.slice(0, 50) + "..." : memory.content;
-                setMessages((prev) => [...prev, createSystemMessage(`Forgot: "${preview}"`)]);
-                await loadMemories();
-            }
-            catch (error) {
-                setMessages((prev) => [
-                    ...prev,
-                    createErrorMessage(`Error forgetting: ${error.message}`),
-                ]);
-            }
-        }
-    }, [dispatchHeadlessCommand, memoryBrowserMode, loadMemories]);
-    const clearAuthInteractionUi = useCallback(() => {
-        setLoginPickerProviders(null);
-        setCopilotSourceOptions(null);
-        setOAuthProvider(null);
-        setOAuthAuthorizeUrl(null);
-        setOAuthExpectedState(null);
-        setOAuthFieldKey(null);
-        setCopilotDeviceProvider(null);
-        setCopilotDeviceProfileLabel(null);
-        setCopilotDeviceVerificationUri(null);
-        setCopilotDeviceUserCode(null);
-        setAnthropicMethodOptions(null);
-        setAnthropicKeyInputVisible(false);
-        setAnthropicSetupTokenVisible(false);
-        setOpenAIMethodOptions(null);
-        setOpenAIKeyInputVisible(false);
-        setGoogleMethodOptions(null);
-        setGoogleKeyInputVisible(false);
-        setPendingAuthInteraction(null);
-        setAuthInteractionOptions(null);
-        setAuthInteractionTitle(null);
-        setAuthInteractionInput(null);
-    }, []);
-    const applyAuthCommandResult = useCallback((result) => {
-        const authResult = result;
-        const success = authResult.success !== false;
-        const message = authResult.message ?? (success ? "Authentication updated." : "Auth failed.");
-        setMessages((prev) => [
-            ...prev,
-            success ? createSystemMessage(message) : createErrorMessage(message),
-        ]);
-    }, []);
-    const showAuthInteraction = useCallback(async (frame) => {
-        clearAuthInteractionUi();
-        if (frame.interaction.kind === "selection") {
-            setPendingAuthInteraction({
-                interactionId: frame.interactionId,
-                interaction: frame.interaction,
-            });
-            setAuthInteractionTitle(frame.interaction.prompt);
-            setAuthInteractionOptions(frame.interaction.options.map((option) => ({
-                id: option.id,
-                label: option.label,
-                description: option.description,
-                method: option.id,
-                status: option.description?.includes("connected")
-                    ? "connected"
-                    : option.description?.includes("available")
-                        ? "available"
-                        : "none",
-            })));
-            return;
-        }
-        if (frame.interaction.kind === "credential_input") {
-            const field = frame.interaction.fields[0];
-            if (!field) {
-                throw new Error("Auth interaction requires at least one credential field");
-            }
-            if (frame.interaction.mode === "oauth_authorization_code" &&
-                frame.interaction.authorizeUrl &&
-                frame.interaction.provider) {
-                setPendingAuthInteraction({
-                    interactionId: frame.interactionId,
-                    interaction: frame.interaction,
-                });
-                setOAuthProvider(frame.interaction.provider);
-                setOAuthAuthorizeUrl(frame.interaction.authorizeUrl);
-                setOAuthExpectedState(frame.interaction.expectedState ?? null);
-                setOAuthFieldKey(field.key);
-                return;
-            }
-            setPendingAuthInteraction({
-                interactionId: frame.interactionId,
-                interaction: frame.interaction,
-            });
-            setAuthInteractionInput({
-                title: field.label,
-                hint: frame.interaction.prompt,
-                fieldKey: field.key,
-            });
-            return;
-        }
-        if (frame.interaction.kind === "oauth_device") {
-            setPendingAuthInteraction({
-                interactionId: frame.interactionId,
-                interaction: frame.interaction,
-            });
-            setCopilotDeviceProvider(frame.interaction.provider ?? "github-copilot");
-            setCopilotDeviceProfileLabel(frame.interaction.profileLabel ?? null);
-            setCopilotDeviceVerificationUri(frame.interaction.verificationUri);
-            setCopilotDeviceUserCode(frame.interaction.userCode);
-            return;
-        }
-    }, [applyAuthCommandResult, clearAuthInteractionUi, headlessRunKernel]);
-    const dispatchAuthCommand = useCallback(async (op, args) => {
-        clearAuthInteractionUi();
-        const { interactionFrame, resultFrame } = await dispatchHeadlessCommand(op, { args });
-        if (interactionFrame && interactionFrame.source === "auth") {
-            await showAuthInteraction(interactionFrame);
-            return;
-        }
-        if (!resultFrame) {
-            throw new Error(`${op} produced no result frame`);
-        }
-        if (resultFrame.ok) {
-            applyAuthCommandResult(resultFrame.result);
-            return;
-        }
-        throw new Error(resultFrame.error.message);
-    }, [applyAuthCommandResult, clearAuthInteractionUi, dispatchHeadlessCommand, showAuthInteraction]);
-    const respondToPendingAuthInteraction = useCallback(async (response) => {
-        if (!pendingAuthInteraction) {
-            throw new Error("No pending auth interaction to respond to");
-        }
-        const { interactionId } = pendingAuthInteraction;
-        let nextInteraction = null;
-        let resultFrame = null;
-        for await (const frame of headlessRunKernel.dispatch({
-            kind: "interaction.respond",
-            requestId: `auth:${randomUUID()}`,
-            interactionId,
-            response,
-        })) {
-            if (frame.kind === "interaction.required" && frame.source === "auth") {
-                nextInteraction = frame;
-            }
-            else if (frame.kind === "result") {
-                resultFrame = frame;
-            }
-        }
-        if (nextInteraction) {
-            await showAuthInteraction(nextInteraction);
-            return;
-        }
-        clearAuthInteractionUi();
-        if (!resultFrame) {
-            throw new Error("auth interaction produced no result frame");
-        }
-        if (resultFrame.ok) {
-            applyAuthCommandResult(resultFrame.result);
-            return;
-        }
-        if (resultFrame.error.code === "INTERACTION_REQUIRED") {
-            return;
-        }
-        setMessages((prev) => [
-            ...prev,
-            createErrorMessage(`Login failed: ${resultFrame.error.message}`),
-        ]);
-    }, [
-        applyAuthCommandResult,
-        clearAuthInteractionUi,
-        headlessRunKernel,
-        pendingAuthInteraction,
-        showAuthInteraction,
-    ]);
-    const maxContextTokens = useMemo(() => getModelByShortName(model)?.maxContextTokens, [model]);
-    // --- Message edit overlay: build entries for all conversation messages ---
-    const editableMessages = useMemo(() => {
-        return messages
-            .map((msg, index) => {
-            const textParts = (Array.isArray(msg.content) ? msg.content : [msg.content])
-                .filter((b) => typeof b === "object" && b !== null && "type" in b && b.type === "text")
-                .map((b) => b.text);
-            const text = textParts.join("").trim();
-            // Skip empty messages and system messages (they're internal)
-            if (!text || msg.role === "system")
-                return null;
-            return {
-                index,
-                role: msg.role,
-                text,
-                arion: msg.arion?.name,
-                createdAt: msg.createdAt,
-            };
-        })
-            .filter((e) => e !== null);
-    }, [messages]);
-    // Handle edit-message selection from the overlay:
-    // Fork the session at that message point, switch to the fork (like resume),
-    // then put the message text into the input for editing.
-    const [openMessageEditOverlaySignal, setOpenMessageEditOverlaySignal] = useState(undefined);
-    const [prefillInput, setPrefillInput] = useState(undefined);
-    const handleEditMessage = useCallback(async (messageIndex, messageText) => {
-        if (!sessionIdRef.current || isStreamingRef.current)
-            return;
-        // messageIndex is the index in the TUI messages[] array, which may include
-        // system messages (e.g. "Resumed session...") that are NOT in the database.
-        // We need to count only non-system messages before the selected index,
-        // because those correspond 1:1 with the DB rows ordered by id ASC.
-        let dbMessageCount = 0;
-        for (let i = 0; i < messageIndex; i++) {
-            const msg = messages[i];
-            if (msg && msg.role !== "system") {
-                dbMessageCount++;
-            }
-        }
-        const messageLimit = dbMessageCount;
-        try {
-            const { resultFrame } = await dispatchHeadlessCommand("session.fork", {
-                sessionId: sessionIdRef.current,
-                messageLimit,
-            });
-            if (!resultFrame?.ok) {
-                const errorMsg = resultFrame?.error?.message ?? "Fork failed";
-                setMessages((prev) => [...prev, createErrorMessage(`Edit failed: ${errorMsg}`)]);
-                return;
-            }
-            const forkResult = resultFrame.result;
-            // Switch to the forked session (like resume — shows messages up to the fork point)
-            await handleSelectSession(forkResult.newSessionId);
-            // Put the message text into the input box for editing.
-            // The REPL screen's App component exposes onSetInput via the inputRef,
-            // but we can set it via the return value which triggers a re-render.
-            setPrefillInput(messageText);
-        }
-        catch (error) {
-            setMessages((prev) => [
-                ...prev,
-                createErrorMessage(`Edit failed: ${error.message}`),
-            ]);
-        }
-    }, [messages, dispatchHeadlessCommand, handleSelectSession]);
-    return (_jsx(REPL, { staticRenderEpoch: staticRenderEpoch, session: session, model: model, maxContextTokens: maxContextTokens, banner: _jsx(Banner, { onComplete: () => { }, skipAnimation: true, version: CLI_VERSION, whatsNew: WHATS_NEW }), messages: messages, previewMessages: previewMessages, isStreaming: isStreaming, queuedMessage: queuedMessage, onCancelQueuedMessage: handleCancelQueuedMessage, responseTime: responseTime, commands: COMMANDS, arions: arions, models: models, memories: memories, memoryBrowserMode: memoryBrowserMode, isLoadingMemories: isLoadingMemories, userName: userName, memoryCount: memoryCount, metrics: metrics, displayMode: displayMode, displayConfig: displayConfig, showThinking: displayConfig.showThinking, showCosts: displayConfig.showCosts, showTraces: displayConfig.showTraces, pipelineTiming: pipelineTiming, spans: spans, activeArion: activeArion, onSubmit: handleSubmit, onCommand: handleCommand, onSelectArion: handleSelectArion, onSelectModel: handleSelectModel, onSelectMemory: handleSelectMemory, onOpenMemoryBrowser: handleOpenMemoryBrowser, onToggleThinking: handleToggleThinking, onToggleCosts: handleToggleCosts, onToggleTraces: handleToggleTraces, onCycleDisplayMode: handleCycleDisplayMode, sessions: sessions, onSelectSession: handleSelectSession, onLoadSessions: loadSessions, onSearchSessions: handleSearchSessions, onLoadMoreSessions: handleLoadMoreSessions, openSessionOverlaySignal: openSessionOverlaySignal, openThemeOverlaySignal: openThemeOverlaySignal, openSoundOverlaySignal: openSoundOverlaySignal, openDaemonOverlaySignal: openDaemonOverlaySignal, daemonStatus: daemonStatus, daemonActionStatus: daemonActionStatus, onDaemonAction: handleDaemonAction, connectionState: connectionState, inviteShare: inviteShare
-            ? {
-                inviteToken: inviteShare.inviteToken,
-                inviteLabel: inviteShare.pendingInvite.inviteLabel,
-                expiresAt: inviteShare.pendingInvite.expiresAt ?? null,
-            }
-            : null, onInviteShareClose: () => {
-            setInviteShare(null);
-        }, openJoinInviteOverlaySignal: openJoinInviteOverlaySignal, onJoinInviteSubmit: handleJoinInviteToken, onJoinInviteCancel: () => {
-            setJoinInviteError(null);
-        }, joinInviteError: joinInviteError, onSelectTheme: handleSelectTheme, inputHistory: inputHistory, onSaveInput: onSaveInput, openMessageEditOverlaySignal: openMessageEditOverlaySignal, editableMessages: editableMessages, onEditMessage: handleEditMessage, prefillInput: prefillInput, onPrefillConsumed: () => setPrefillInput(undefined), obsCtx: obsCtx, onCancel: handleCancel, approvalRequest: approvalRequest, onApprovalChoice: (approved) => {
-            if (approvalRequest) {
-                approvalRequest.resolve(approved);
-                setApprovalRequest(null);
-            }
-        }, effortLevel: effortLevel, showAutonomySelector: showAutonomySelector, autonomyLevel: autonomyLevelState, onAutonomySelect: (level) => {
-            setAutonomyLevel(level);
-            setShowAutonomySelector(false);
-            setMessages((prev) => [...prev, createSystemMessage(`Autonomy level set to: ${level}`)]);
-        }, onCycleAutonomy: () => {
-            const idx = AUTONOMY_LEVELS.indexOf(autonomyLevelRef.current);
-            const next = AUTONOMY_LEVELS[(idx + 1) % AUTONOMY_LEVELS.length];
-            setAutonomyLevel(next);
-        }, onCycleEffort: () => {
-            const levels = ["low", "medium", "high", "max"];
-            const idx = levels.indexOf(effortLevel);
-            const next = levels[(idx + 1) % levels.length];
-            setEffortLevel(next);
-            const cfg = loadConfig();
-            cfg.effortLevel = next;
-            saveConfig(cfg);
-        }, onAutonomyCancel: () => {
-            setShowAutonomySelector(false);
-        }, authInteractionOptions: authInteractionOptions, authInteractionTitle: authInteractionTitle, onAuthInteractionSelect: async (optionId) => {
-            await respondToPendingAuthInteraction({ kind: "selection", selected: optionId });
-        }, onAuthInteractionCancel: async () => {
-            await respondToPendingAuthInteraction({ kind: "cancel" });
-        }, authInteractionInput: authInteractionInput
-            ? {
-                title: authInteractionInput.title,
-                ...(authInteractionInput.hint ? { hint: authInteractionInput.hint } : {}),
-            }
-            : null, onAuthInteractionInputSubmit: async (value) => {
-            if (!authInteractionInput) {
-                return;
-            }
-            await respondToPendingAuthInteraction({
-                kind: "credential_input",
-                values: {
-                    [authInteractionInput.fieldKey]: value,
-                },
-            });
-        }, onAuthInteractionInputCancel: async () => {
-            await respondToPendingAuthInteraction({ kind: "cancel" });
-        }, loginPickerProviders: loginPickerProviders, onLoginProviderSelect: async (provider) => {
-            setLoginPickerProviders(null);
-            await dispatchAuthCommand("auth.login", provider.id);
-        }, onLoginPickerCancel: () => {
-            setLoginPickerProviders(null);
-        }, anthropicMethodOptions: anthropicMethodOptions, onAnthropicMethodSelect: async (option) => {
-            setAnthropicMethodOptions(null);
-            await dispatchAuthCommand("auth.login", `anthropic --method ${option.id}`);
-        }, onAnthropicMethodCancel: () => setAnthropicMethodOptions(null), anthropicKeyInputVisible: anthropicKeyInputVisible, onAnthropicKeySubmit: async (apiKey) => {
-            setAnthropicKeyInputVisible(false);
-            await dispatchAuthCommand("auth.login", `anthropic ${apiKey}`);
-        }, onAnthropicKeyCancel: () => setAnthropicKeyInputVisible(false), anthropicSetupTokenVisible: anthropicSetupTokenVisible, onAnthropicSetupTokenSubmit: async (token) => {
-            setAnthropicSetupTokenVisible(false);
-            await dispatchAuthCommand("auth.login", `anthropic --setup-token ${token}`);
-        }, onAnthropicSetupTokenCancel: () => setAnthropicSetupTokenVisible(false), openaiMethodOptions: openaiMethodOptions, onOpenAIMethodSelect: async (option) => {
-            setOpenAIMethodOptions(null);
-            await dispatchAuthCommand("auth.login", `openai --method ${option.id}`);
-        }, onOpenAIMethodCancel: () => setOpenAIMethodOptions(null), openaiKeyInputVisible: openaiKeyInputVisible, onOpenAIKeySubmit: async (apiKey) => {
-            setOpenAIKeyInputVisible(false);
-            await dispatchAuthCommand("auth.login", `openai ${apiKey}`);
-        }, onOpenAIKeyCancel: () => setOpenAIKeyInputVisible(false), googleMethodOptions: googleMethodOptions, onGoogleMethodSelect: async (option) => {
-            setGoogleMethodOptions(null);
-            await dispatchAuthCommand("auth.login", `google --method ${option.id}`);
-        }, onGoogleMethodCancel: () => setGoogleMethodOptions(null), googleKeyInputVisible: googleKeyInputVisible, onGoogleKeySubmit: async (apiKey) => {
-            setGoogleKeyInputVisible(false);
-            await dispatchAuthCommand("auth.login", `google ${apiKey}`);
-        }, onGoogleKeyCancel: () => setGoogleKeyInputVisible(false), copilotSourceOptions: copilotSourceOptions, onCopilotSourceSelect: async (source) => {
-            setCopilotSourceOptions(null);
-            await dispatchAuthCommand("auth.login", `github-copilot --from ${source.id}`);
-        }, onCopilotSourceCancel: () => setCopilotSourceOptions(null), oauthProvider: oauthProvider, oauthAuthorizeUrl: oauthAuthorizeUrl, oauthExpectedState: oauthExpectedState, onOAuthComplete: (result) => {
-            setOAuthProvider(null);
-            setOAuthAuthorizeUrl(null);
-            setOAuthExpectedState(null);
-            setOAuthFieldKey(null);
-            setMessages((prev) => [
-                ...prev,
-                result.success ? createSystemMessage(result.message) : createErrorMessage(result.message),
-            ]);
-        }, onOAuthCodeSubmit: async (code) => {
-            if (!oauthFieldKey) {
-                throw new Error("No pending OAuth field key");
-            }
-            await respondToPendingAuthInteraction({
-                kind: "credential_input",
-                values: {
-                    [oauthFieldKey]: code,
-                },
-            });
-        }, onOAuthCancel: async () => {
-            await respondToPendingAuthInteraction({ kind: "cancel" });
-        }, copilotDeviceProvider: copilotDeviceProvider, copilotDeviceProfileLabel: copilotDeviceProfileLabel, copilotDeviceVerificationUri: copilotDeviceVerificationUri, copilotDeviceUserCode: copilotDeviceUserCode, onCopilotDeviceComplete: (result) => {
-            setCopilotDeviceProvider(null);
-            setCopilotDeviceProfileLabel(null);
-            setCopilotDeviceVerificationUri(null);
-            setCopilotDeviceUserCode(null);
-            setMessages((prev) => [
-                ...prev,
-                result.success ? createSystemMessage(result.message) : createErrorMessage(result.message),
-            ]);
-        }, onCopilotDeviceApprove: async () => {
-            await respondToPendingAuthInteraction({ kind: "oauth_device", acknowledged: true });
-        }, onCopilotDeviceCancel: async () => {
-            await respondToPendingAuthInteraction({ kind: "cancel" });
-        }, nearbyPeers: nearbyPeers, localClients: localClients, onSelectPeer: handleSelectPeer, onSelectClient: () => { }, onPeerCancel: () => { }, onClientsCancel: () => { }, openPeersOverlaySignal: openPeersOverlaySignal, openClientsOverlaySignal: openClientsOverlaySignal, incomingPairRequest: incomingPairRequest, onAcceptPairRequest: handleAcceptPairRequest, onRejectPairRequest: handleRejectPairRequest, onCancelPairing: undefined, meshMessageCount: meshMessageCount, runtimeSocket: runtimeSocket, clientId: headlessRunKernel?.getAttachedCredentials()?.clientId ?? null, clientAuthToken: headlessRunKernel?.getAttachedCredentials()?.clientAuthToken ?? null, resolveCredentials: async () => {
-            try {
-                return headlessRunKernel?.getAttachedCredentials() ?? null;
-            }
-            catch {
-                return null;
-            }
-        } }));
-}
-export async function startInkRepl(session, manager, router, aria, attachedLocalControl, cliContext, inputHistory = [], onSaveInput, sessionHistory, initialMessage, cachedUserName, resumeSessionId, initialAvailableModels, refreshAvailableModels, credentialHints, authResolver) {
-    // When the daemon supports session write IPC, wrap sessionHistory in a
-    // client that routes writes over IPC (fire-and-forget, zero event-loop
-    // blocking) while keeping reads local (instant WAL reads).
-    const localControlManager = new LocalControlManager(attachedLocalControl);
-    let effectiveHistory = sessionHistory;
-    const control = localControlManager.getControl();
-    if (sessionHistory && !(sessionHistory instanceof SessionHistoryClient) && control != null) {
-        effectiveHistory = new SessionHistoryClient(sessionHistory, control);
-    }
-    const { waitUntilExit, unmount } = render(_jsx(InkRepl, { session: session, manager: manager, router: router, aria: aria, localControlManager: localControlManager, cliContext: cliContext, sessionHistory: effectiveHistory, inputHistory: inputHistory, onSaveInput: onSaveInput, initialMessage: initialMessage, resumeSessionId: resumeSessionId, cachedUserName: cachedUserName, initialAvailableModels: initialAvailableModels, refreshAvailableModels: refreshAvailableModels, credentialHints: credentialHints, authResolver: authResolver }), { exitOnCtrlC: false, patchConsole: true });
-    let forceExitHandler;
-    let shutdownTimer;
-    let sigintRequested = false;
-    const armForceExitWindow = () => {
-        if (!forceExitHandler) {
-            forceExitHandler = () => {
-                process.exit(0);
-            };
-            process.on("SIGINT", forceExitHandler);
-        }
-        if (!shutdownTimer) {
-            shutdownTimer = setTimeout(() => {
-                log.debug("[InkREPL] Graceful shutdown timed out after 5s — forcing exit");
-                process.exit(0);
-            }, 5000);
-            shutdownTimer.unref?.();
-        }
-    };
-    const onSigint = () => {
-        if (sigintRequested) {
-            return;
-        }
-        sigintRequested = true;
-        process.removeListener("SIGINT", onSigint);
-        armForceExitWindow();
-        void localControlManager.release().catch((error) => {
-            log.warn("[InkREPL] Local-control release during SIGINT failed:", error?.message ?? error);
-        });
-        unmount();
-    };
-    process.on("SIGINT", onSigint);
-    try {
-        await waitUntilExit();
-        // Graceful shutdown — mark session completed and end Memoria session before
-        // process exit. The useEffect cleanup in InkRepl fires async (React doesn't
-        // await it), so this is the reliable path. Second Ctrl+C forces immediate exit.
-        armForceExitWindow();
-        try {
-            const { sessionId, sessionHistory: sh, memoriaSession, memoriaFactory } = _shutdownState;
-            // Mark session as completed in SQLite history
-            if (sh && sessionId) {
-                try {
-                    sh.markCompleted(sessionId);
-                }
-                catch (err) {
-                    log.warn("[InkREPL] Failed to mark session completed:", err?.message ?? err);
-                }
-            }
-            // End the Memoria session so sessions table records ended_at
-            if (memoriaSession && sessionId) {
-                try {
-                    await memoriaSession.endSession(sessionId);
-                }
-                catch (err) {
-                    log.warn("[InkREPL] Failed to end Memoria session:", err?.message ?? err);
-                }
-            }
-            // Flush SQLite WAL connections
-            if (memoriaFactory) {
-                try {
-                    await memoriaFactory.closeAll();
-                }
-                catch (err) {
-                    log.warn("[InkREPL] Failed to close Memoria factory:", err?.message ?? err);
-                }
-            }
-            // Flush and close JSONL event logger
-            if (_shutdownState.jsonlLogger) {
-                try {
-                    await _shutdownState.jsonlLogger.close();
-                }
-                catch (err) {
-                    log.warn("[InkREPL] Failed to close JSONL logger:", err?.message ?? err);
-                }
-                _shutdownState.jsonlLogger = null;
-            }
-        }
-        finally {
-            if (shutdownTimer) {
-                clearTimeout(shutdownTimer);
-                shutdownTimer = undefined;
-            }
-        }
-    }
-    finally {
-        process.removeListener("SIGINT", onSigint);
-        if (forceExitHandler) {
-            process.removeListener("SIGINT", forceExitHandler);
-        }
-        await localControlManager.release().catch((err) => {
-            log.warn("[InkREPL] Local-control release on shutdown failed:", err?.message ?? err);
-        });
-    }
-    // Close Aria's Memoria and any manager-cached instances
-    try {
-        await aria.shutdown();
-    }
-    catch (err) {
-        log.warn("[InkREPL] Shutdown failed:", err?.message);
-    }
-}
-//# sourceMappingURL=ink-repl.js.map