@aria-cli/cli 1.0.57 → 1.0.59

package/dist/headless/kernel.js

@@ -1,785 +0,0 @@
-import path, { join } from "node:path";
-import { createLazyAttachedLocalControlApi, logReattach, } from "../local-control-lazy-wrapper.js";
-import { ArionManager, ArionStorage, MemoriaPool } from "@aria-cli/aria";
-import { selectRunnableModelVariant, } from "@aria-cli/models";
-import { HEADLESS_OPERATION_SCHEMAS } from "@aria-cli/tools";
-import { createCliContext } from "../cli-context.js";
-import { loadConfig, saveConfig } from "../config.js";
-import { SessionHistory, } from "../history/index.js";
-import { cliStallPhase } from "../history/stall-phase-bridge.js";
-import { attachLocalControlClient } from "../local-control-client.js";
-import { createArionOperationHandlers } from "./operations/arion.js";
-import { createAuthOperationHandlers } from "./operations/auth.js";
-import { buildStructuredLoginArgs, buildStructuredLogoutArgs, getHeadlessAuthProviders, runHeadlessLogin, runHeadlessLogout, } from "./auth-service.js";
-import { createClientOperationHandlers } from "./operations/client.js";
-import { createConfigOperationHandlers } from "./operations/config.js";
-import { createDaemonOperationHandlers } from "./operations/daemon.js";
-import { createRunOperationHandlers } from "./operations/index.js";
-import { createHookOperationHandlers } from "./operations/hook.js";
-import { createMemoryOperationHandlers } from "./operations/memory.js";
-import { createMessageOperationHandlers } from "./operations/message.js";
-import { createModelOperationHandlers } from "./operations/model.js";
-import { createPeerOperationHandlers } from "./operations/peer.js";
-import { createSessionOperationHandlers } from "./operations/session.js";
-import { createSystemOperationHandlers } from "./operations/system.js";
-import { createDaemonService } from "./daemon-service.js";
-import { createHookService } from "./hook-service.js";
-import { HeadlessAuthOrchestrator } from "./auth-orchestrator.js";
-import { HeadlessRunOrchestrator } from "./run-orchestrator.js";
-import { isTerminalSetupSupported, runTerminalSetup } from "../commands/terminal-setup.js";
-import { getAvailableThemes, getTheme, setTheme } from "../ui/theme/index.js";
-async function releaseHeadlessKernelBootstrapResources(resources) {
-    const failures = [];
-    for (const sessionLedger of resources.sessionLedgers ?? []) {
-        try {
-            sessionLedger?.close();
-        }
-        catch (error) {
-            failures.push(error);
-        }
-    }
-    for (const attachedClient of resources.attachedClients ?? []) {
-        try {
-            await attachedClient?.release();
-        }
-        catch (error) {
-            failures.push(error);
-        }
-    }
-    try {
-        await resources.daemon?.releaseAll?.();
-    }
-    catch (error) {
-        failures.push(error);
-    }
-    try {
-        await resources.managerPool?.closeAll();
-    }
-    catch (error) {
-        failures.push(error);
-    }
-    try {
-        await resources.cli?.pool.closeAll();
-    }
-    catch (error) {
-        failures.push(error);
-    }
-    if (failures.length === 1) {
-        throw failures[0];
-    }
-    if (failures.length > 1) {
-        throw new AggregateError(failures, "Failed to release headless kernel bootstrap resources");
-    }
-}
-const ATTACHED_CLIENT_ATTACH_TIMEOUT_MS = 10_000;
-function withTimeout(promise, timeoutMs, message) {
-    return new Promise((resolve, reject) => {
-        const timeoutId = setTimeout(() => {
-            reject(new Error(message));
-        }, timeoutMs);
-        timeoutId.unref?.();
-        promise.then((value) => {
-            clearTimeout(timeoutId);
-            resolve(value);
-        }, (error) => {
-            clearTimeout(timeoutId);
-            reject(error);
-        });
-    });
-}
-function failureResult(requestId, op, code, message, details) {
-    return {
-        kind: "result",
-        requestId,
-        op,
-        ok: false,
-        error: {
-            code,
-            message,
-            ...(details ? { details } : {}),
-        },
-    };
-}
-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));
-    const byQualifiedExact = sorted.find((model) => {
-        const qualified = `${model.provider}/${model.shortName}`.toLowerCase();
-        return qualified === normalized;
-    });
-    if (byQualifiedExact) {
-        return byQualifiedExact;
-    }
-    const exact = sorted.find((model) => model.shortName.toLowerCase() === normalized);
-    if (exact) {
-        return selectRunnableModelVariant(exact, credentialHints);
-    }
-    const byPrefix = sorted.find((model) => model.shortName.toLowerCase().startsWith(normalized));
-    if (byPrefix) {
-        return selectRunnableModelVariant(byPrefix, credentialHints);
-    }
-    const byQualifiedPrefix = sorted.find((model) => {
-        const qualified = `${model.provider}/${model.shortName}`.toLowerCase();
-        return qualified.startsWith(normalized);
-    });
-    if (byQualifiedPrefix) {
-        return byQualifiedPrefix;
-    }
-    const byTier = sorted.find((model) => model.tier.toLowerCase() === normalized);
-    if (byTier) {
-        return selectRunnableModelVariant(byTier, credentialHints);
-    }
-    const byDisplay = sorted.find((model) => model.displayName.toLowerCase().includes(normalized));
-    if (byDisplay) {
-        return selectRunnableModelVariant(byDisplay, credentialHints);
-    }
-    const byProvider = sorted.find((model) => model.provider.toLowerCase().includes(normalized));
-    return byProvider ? selectRunnableModelVariant(byProvider, credentialHints) : undefined;
-}
-function unsupportedOperationHandler(op) {
-    return async function* (requestId) {
-        yield failureResult(requestId, op, "UNSUPPORTED_OPERATION", `Operation ${op} is not implemented in the kernel yet.`);
-    };
-}
-export function createHeadlessKernelHandlers(ctx) {
-    // If no daemon service was provided (e.g. the REPL path), create one
-    // using the caller-supplied localControl — the REPL's already-attached
-    // connection that reliably reaches the shared daemon.
-    if (!ctx.daemon) {
-        ctx.daemon = createDaemonService({
-            cli: ctx.cli,
-            cwd: process.cwd(),
-            arionName: ctx.getSessionArion?.() ?? ctx.cli.config.activeArion ?? "ARIA",
-            localControl: ctx.localControl,
-        });
-    }
-    const orchestrator = new HeadlessRunOrchestrator({
-        localControl: ctx.localControl,
-        sessionLedger: ctx.sessionLedger,
-        activeRunController: ctx.activeRunController,
-        getSessionModel: ctx.getSessionModel,
-        getSessionArion: ctx.getSessionArion,
-    });
-    const authOrchestrator = new HeadlessAuthOrchestrator(ctx.auth, ctx.sessionLedger, async () => (await ctx.config?.getActiveArion?.()) ??
-        ctx.cli?.config?.activeArion ??
-        "ARIA");
-    const runHandlers = createRunOperationHandlers(orchestrator);
-    const memoryHandlers = createMemoryOperationHandlers(ctx);
-    const arionHandlers = createArionOperationHandlers(ctx);
-    const modelHandlers = createModelOperationHandlers(ctx);
-    const authHandlers = createAuthOperationHandlers(ctx, authOrchestrator);
-    const configHandlers = createConfigOperationHandlers(ctx);
-    const daemonHandlers = createDaemonOperationHandlers(ctx);
-    const hookHandlers = createHookOperationHandlers(ctx);
-    const systemHandlers = createSystemOperationHandlers(ctx);
-    const peerHandlers = createPeerOperationHandlers(ctx);
-    const clientHandlers = createClientOperationHandlers(ctx);
-    const messageHandlers = createMessageOperationHandlers(ctx);
-    const sessionHandlers = createSessionOperationHandlers(ctx);
-    return {
-        "run.start": runHandlers["run.start"],
-        "run.resume": runHandlers["run.resume"],
-        "run.abort": runHandlers["run.abort"],
-        "interaction.respond": async function* (requestId, input, context) {
-            const response = input && typeof input === "object" && "kind" in input
-                ? input
-                : {
-                    kind: "interaction.respond",
-                    requestId,
-                    ...input,
-                };
-            const interaction = ctx.sessionLedger.getInteraction(response.interactionId);
-            if (interaction?.source === "auth") {
-                yield* authOrchestrator.respond(response, context);
-                return;
-            }
-            yield* runHandlers["interaction.respond"](requestId, response, context);
-        },
-        "session.list": sessionHandlers["session.list"],
-        "session.read": sessionHandlers["session.read"],
-        "session.load": sessionHandlers["session.load"],
-        "session.fork": sessionHandlers["session.fork"],
-        "memory.remember": memoryHandlers["memory.remember"],
-        "memory.recall": memoryHandlers["memory.recall"],
-        "memory.list": memoryHandlers["memory.list"],
-        "memory.forget": memoryHandlers["memory.forget"],
-        "memory.recall_knowledge": memoryHandlers["memory.recall_knowledge"],
-        "arion.list": arionHandlers["arion.list"],
-        "arion.hatch": arionHandlers["arion.hatch"],
-        "arion.become": arionHandlers["arion.become"],
-        "arion.rest": arionHandlers["arion.rest"],
-        "arion.wake": arionHandlers["arion.wake"],
-        "arion.create": arionHandlers["arion.create"],
-        "model.list": modelHandlers["model.list"],
-        "model.set": modelHandlers["model.set"],
-        "model.refresh": modelHandlers["model.refresh"],
-        "auth.status": authHandlers["auth.status"],
-        "auth.login": authHandlers["auth.login"],
-        "auth.logout": authHandlers["auth.logout"],
-        "auth.clear_session": authHandlers["auth.clear_session"],
-        "auth.import_env_session": authHandlers["auth.import_env_session"],
-        "peer.list": peerHandlers["peer.list"],
-        "peer.list_nearby": peerHandlers["peer.list_nearby"],
-        "peer.pending.list": peerHandlers["peer.pending.list"],
-        "peer.pending.respond": peerHandlers["peer.pending.respond"],
-        "peer.invite": peerHandlers["peer.invite"],
-        "peer.connect": peerHandlers["peer.connect"],
-        "peer.accept_invite": peerHandlers["peer.accept_invite"],
-        "peer.direct_pair": peerHandlers["peer.direct_pair"],
-        "peer.repair": peerHandlers["peer.repair"],
-        "peer.revoke": peerHandlers["peer.revoke"],
-        "client.list": clientHandlers["client.list"],
-        "client.inbox.list": clientHandlers["client.inbox.list"],
-        "message.send": messageHandlers["message.send"],
-        "message.inbox.list": messageHandlers["message.inbox.list"],
-        "config.theme.get": configHandlers["config.theme.get"],
-        "config.theme.set": configHandlers["config.theme.set"],
-        "config.autonomy.get": configHandlers["config.autonomy.get"],
-        "config.autonomy.set": configHandlers["config.autonomy.set"],
-        "system.restart": systemHandlers["system.restart"],
-        "system.terminal_setup": systemHandlers["system.terminal_setup"],
-        "daemon.start": daemonHandlers["daemon.start"],
-        "daemon.status": daemonHandlers["daemon.status"],
-        "daemon.stop": daemonHandlers["daemon.stop"],
-        "daemon.restart": daemonHandlers["daemon.restart"],
-        "hook.extract": hookHandlers["hook.extract"],
-        "hook.reflect": hookHandlers["hook.reflect"],
-        "hook.consolidate": hookHandlers["hook.consolidate"],
-        "hook.ingest": hookHandlers["hook.ingest"],
-        "hook.harvest": hookHandlers["hook.harvest"],
-    };
-}
-export class HeadlessKernel {
-    ctx;
-    handlers;
-    constructor(ctx, handlers) {
-        this.ctx = ctx;
-        // connectToPublishedRuntimeSocket returns a createResilientAttachedClient-
-        // backed client that handles network failures (ECONNREFUSED, ECONNRESET)
-        // transparently. However, if the ResilientAttachedClient is RELEASED
-        // (e.g. SIGINT race, cleanup ordering), its `released` flag is permanent
-        // and no amount of internal retry can recover — a completely new client
-        // is needed. Wrap with createLazyAttachedLocalControlApi so that
-        // "has been released" (recognized by isStaleLeaseError) triggers cache
-        // invalidation and reconnection via a fresh ResilientAttachedClient.
-        if (!handlers) {
-            const alreadyManaged = ctx.localControl?.__ariaLazyControl;
-            let stale = false;
-            const originalControl = ctx.localControl;
-            if (!alreadyManaged) {
-                ctx.localControl = createLazyAttachedLocalControlApi(async () => {
-                    if (!stale)
-                        return originalControl;
-                    const { createResilientAttachedClient } = await import("../attached-local-control-client.js");
-                    const server = await import("@aria-cli/server");
-                    const runtimeRoot = server.resolveRuntimeRootDirectory();
-                    const owner = server.findRuntimeOwnerRecordByAriaHome(runtimeRoot, ctx.cli.ariaDir);
-                    if (!owner?.runtimeSocket) {
-                        throw new Error("Cannot reconnect: no daemon found after restart");
-                    }
-                    const resilient = await createResilientAttachedClient({
-                        runtimeSocket: owner.runtimeSocket,
-                        clientKind: "local-api",
-                        logDir: join(ctx.cli.ariaDir, "logs"),
-                    });
-                    return resilient.api;
-                }, () => {
-                    stale = true;
-                }, ctx.cli.ariaDir);
-            }
-        }
-        this.handlers = handlers ?? createHeadlessKernelHandlers(ctx);
-    }
-    async *dispatch(frame, context = {}) {
-        if (frame.kind === "interaction.respond") {
-            const parsed = HEADLESS_OPERATION_SCHEMAS["interaction.respond"].input.safeParse({
-                interactionId: frame.interactionId,
-                response: frame.response,
-            });
-            if (!parsed.success) {
-                yield failureResult(frame.requestId, "interaction.respond", "INVALID_INPUT", parsed.error.issues
-                    .map((issue) => `${issue.path.join(".") || "<root>"} ${issue.message}`)
-                    .join("; "));
-                return;
-            }
-            yield* this.handlers["interaction.respond"](frame.requestId, frame, context);
-            return;
-        }
-        const request = frame;
-        const parsed = HEADLESS_OPERATION_SCHEMAS[request.op].input.safeParse(request.input);
-        if (!parsed.success) {
-            yield failureResult(request.requestId, request.op, "INVALID_INPUT", parsed.error.issues
-                .map((issue) => `${issue.path.join(".") || "<root>"} ${issue.message}`)
-                .join("; "));
-            return;
-        }
-        yield* this.handlers[request.op](request.requestId, parsed.data, context);
-    }
-    subscribeDirectClientInbox(cursor) {
-        return this.ctx.localControl.subscribeDirectClientInbox(cursor);
-    }
-    getConnectionState() {
-        const control = this.ctx.localControl;
-        return control.getConnectionState?.() ?? "connected";
-    }
-    onConnectionStateChange(listener) {
-        const control = this.ctx.localControl;
-        return control.onConnectionStateChange?.(listener) ?? (() => { });
-    }
-    getAttachedCredentials() {
-        const control = this.ctx.localControl;
-        const clientId = control.getClientId?.();
-        const clientAuthToken = control.getClientAuthToken?.();
-        if (!clientId || !clientAuthToken)
-            return null;
-        return { clientId, clientAuthToken };
-    }
-    async resolveRuntimeSocket() {
-        return (await this.ctx.resolveRuntimeSocket?.()) ?? null;
-    }
-    getContext() {
-        return this.ctx;
-    }
-}
-export async function createHeadlessKernelRuntime(options) {
-    let cli = null;
-    let managerPool = null;
-    let daemonService = null;
-    const sessionLedgers = new Map();
-    const attachedClientLoads = new Map();
-    const orphanedAttachedClientLoads = new Set();
-    let released = false;
-    const releaseResources = async () => {
-        if (released) {
-            return;
-        }
-        released = true;
-        const attachedClients = await Promise.allSettled([
-            ...attachedClientLoads.values(),
-            ...orphanedAttachedClientLoads.values(),
-        ]);
-        await releaseHeadlessKernelBootstrapResources({
-            sessionLedgers: [...sessionLedgers.values()],
-            attachedClients: attachedClients.flatMap((result) => result.status === "fulfilled" ? [result.value] : []),
-            daemon: daemonService,
-            managerPool,
-            cli,
-        });
-    };
-    try {
-        cli = await createCliContext({
-            cwd: options?.cwd,
-            skipDiscoveryRefresh: true,
-        });
-        const activeCli = cli;
-        let currentArionName = options?.arionName ?? activeCli.config.activeArion ?? "ARIA";
-        let currentModelName;
-        const getCurrentArionName = () => currentArionName;
-        const getCurrentModelName = () => currentModelName;
-        const persistCurrentArionName = (name) => {
-            currentArionName = name;
-            const config = loadConfig();
-            config.activeArion = name;
-            saveConfig(config);
-        };
-        const ensureSessionLedger = (arionName) => {
-            let ledger = sessionLedgers.get(arionName);
-            if (!ledger) {
-                ledger = new SessionHistory(SessionHistory.resolvePerArionPath(activeCli.ariaDir, arionName), { stallPhase: cliStallPhase });
-                sessionLedgers.set(arionName, ledger);
-            }
-            return ledger;
-        };
-        const tryConnectToDaemonSocket = async () => {
-            try {
-                const { resolveRuntimeRootDirectory, findRuntimeOwnerRecordByAriaHome } = await import("@aria-cli/server");
-                const { createResilientAttachedClient } = await import("../local-control-client.js");
-                const runtimeRoot = resolveRuntimeRootDirectory();
-                const owner = findRuntimeOwnerRecordByAriaHome(runtimeRoot, activeCli.ariaDir);
-                if (!owner?.runtimeSocket) {
-                    return null;
-                }
-                // Use the resilient client factory — it owns lease acquisition,
-                // auth, reattach with backoff, and logging. The returned API
-                // survives daemon restarts transparently.
-                const resilient = await createResilientAttachedClient({
-                    runtimeSocket: owner.runtimeSocket,
-                    clientKind: "local-api",
-                    logDir: join(activeCli.ariaDir, "logs"),
-                });
-                return {
-                    nodeId: owner.nodeId,
-                    runtimeId: (owner.runtimeId ?? "daemon"),
-                    port: 0,
-                    ownership: "reattached",
-                    control: resilient.api,
-                    attachedClientId: resilient.getClientId(),
-                    attachedClientAuthToken: resilient.getClientAuthToken(),
-                    release: () => resilient.release(),
-                };
-            }
-            catch (err) {
-                logReattach(activeCli.ariaDir, {
-                    event: "daemon_socket_connect_failed",
-                    error: err instanceof Error ? err.message : String(err),
-                });
-                return null;
-            }
-        };
-        const ensureAttachedClient = async (arionName) => {
-            let managedLoad = attachedClientLoads.get(arionName);
-            if (!managedLoad) {
-                managedLoad = (async () => {
-                    // Connect to the running daemon's socket. CLI subcommands are
-                    // pure clients — they never create runtimes. Only the daemon
-                    // and interactive REPL own runtimes.
-                    const daemonClient = await tryConnectToDaemonSocket();
-                    if (daemonClient) {
-                        logReattach(activeCli.ariaDir, {
-                            event: "ensureAttachedClient_resolved",
-                            path: "daemon_socket",
-                            arionName,
-                        });
-                        if (released) {
-                            await daemonClient.release().catch(() => { });
-                        }
-                        return daemonClient;
-                    }
-                    logReattach(activeCli.ariaDir, {
-                        event: "ensureAttachedClient_fallback",
-                        path: "attachLocalControlClient",
-                        arionName,
-                    });
-                    // No daemon found via runtime root. Fall back to
-                    // attachLocalControlClient which goes through the HostSupervisor.
-                    // If a daemon IS running (missed by tryConnectToDaemonSocket due
-                    // to ARIA_HOME mismatch), the supervisor's split-brain detection
-                    // will catch it and connect to the daemon's socket. Otherwise it
-                    // creates a standalone scoped runtime (for aria headless mode).
-                    let client;
-                    try {
-                        client = await attachLocalControlClient({
-                            ariaHome: activeCli.ariaDir,
-                            arionName,
-                            clientKind: "local-api",
-                            runtimeLifecycle: "scoped",
-                            memoriaFactory: activeCli.memoriaFactory,
-                            router: activeCli.router,
-                            authResolver: activeCli.authResolver,
-                            runSessionConfig: activeCli.config,
-                            mcpServers: activeCli.projectConfig.mcp?.servers,
-                            silent: true,
-                        });
-                    }
-                    catch (err) {
-                        if (err instanceof Error && err.message.includes("already in use")) {
-                            throw new Error("A daemon is running but could not be reached. " +
-                                "Ensure ARIA_HOME matches the daemon's home directory, " +
-                                "or stop the daemon with: aria-stop");
-                        }
-                        throw err;
-                    }
-                    if (released) {
-                        await client.release().catch(() => { });
-                    }
-                    return client;
-                })();
-                attachedClientLoads.set(arionName, managedLoad);
-            }
-            return withTimeout(managedLoad, ATTACHED_CLIENT_ATTACH_TIMEOUT_MS, `Timed out attaching local control for ${arionName}`).catch((error) => {
-                orphanedAttachedClientLoads.add(managedLoad);
-                void managedLoad.finally(() => {
-                    orphanedAttachedClientLoads.delete(managedLoad);
-                });
-                attachedClientLoads.delete(arionName);
-                throw error;
-            });
-        };
-        const localControl = createLazyAttachedLocalControlApi(async () => {
-            const attachedClient = await ensureAttachedClient(getCurrentArionName());
-            return attachedClient.control;
-        }, () => {
-            // Server restarted — our lease is stale. Clear the cached client
-            // so ensureAttachedClient performs a fresh attach on the next call.
-            const arionName = getCurrentArionName();
-            const staleLoad = attachedClientLoads.get(arionName);
-            if (staleLoad) {
-                orphanedAttachedClientLoads.add(staleLoad);
-                void staleLoad
-                    .then((client) => client.release().catch(() => { }))
-                    .finally(() => orphanedAttachedClientLoads.delete(staleLoad));
-                attachedClientLoads.delete(arionName);
-            }
-        }, activeCli.ariaDir);
-        const sessionLedger = new Proxy({}, {
-            get(_target, propertyKey) {
-                const ledger = ensureSessionLedger(getCurrentArionName());
-                const member = ledger[propertyKey];
-                return typeof member === "function" ? member.bind(ledger) : member;
-            },
-        });
-        ensureSessionLedger(currentArionName);
-        managerPool = new MemoriaPool(activeCli.ariaDir);
-        const arionManager = new ArionManager(new ArionStorage(activeCli.ariaDir), managerPool.toFactory());
-        arionManager.setRouter(activeCli.router);
-        await arionManager.initialize();
-        let availableModels = activeCli.availableModels;
-        const resolveMemoriaPath = async () => {
-            const configuredArionName = getCurrentArionName();
-            const configuredArion = await arionManager.get(configuredArionName);
-            return configuredArion?.memoriaPath ?? path.join("arions", configuredArionName, "memory.db");
-        };
-        const loadMemoria = async () => {
-            const resolvedMemoria = await activeCli.pool.get(await resolveMemoriaPath());
-            return resolvedMemoria;
-        };
-        const memoria = new Proxy({}, {
-            get(_target, propertyKey) {
-                return async (...args) => {
-                    const resolvedMemoria = await loadMemoria();
-                    const member = resolvedMemoria[propertyKey];
-                    if (typeof member !== "function") {
-                        return member;
-                    }
-                    return member.apply(resolvedMemoria, args);
-                };
-            },
-        });
-        daemonService = createDaemonService({
-            cli: activeCli,
-            cwd: options?.cwd ?? process.cwd(),
-            arionName: getCurrentArionName(),
-            getArionName: getCurrentArionName,
-            localControl,
-        });
-        const hookService = createHookService({
-            cli: activeCli,
-            arionName: getCurrentArionName(),
-            getArionName: getCurrentArionName,
-            resolveMemoriaPath,
-        });
-        const ctx = {
-            cli: activeCli,
-            localControl,
-            sessionLedger,
-            arionManager: {
-                list: () => arionManager.list(),
-                hatch: (input) => arionManager.hatch(input),
-                get: (name) => arionManager.get(name),
-                wake: (name) => arionManager.wake(name),
-                rest: (name, restOptions) => arionManager.rest(name, restOptions),
-            },
-            memoria,
-            config: {
-                async getTheme() {
-                    return loadConfig().theme ?? getTheme().name;
-                },
-                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 loadConfig().autonomy ?? "balanced";
-                },
-                async setAutonomy(autonomy) {
-                    if (!["minimal", "balanced", "high", "full"].includes(autonomy)) {
-                        throw new Error(`Invalid autonomy level: ${autonomy}`);
-                    }
-                    const config = loadConfig();
-                    config.autonomy = autonomy;
-                    saveConfig(config);
-                    return { autonomy };
-                },
-                async getActiveArion() {
-                    return getCurrentArionName();
-                },
-                async setActiveArion(name) {
-                    persistCurrentArionName(name);
-                },
-            },
-            auth: (() => {
-                return {
-                    async status() {
-                        let sessionProviders = [];
-                        try {
-                            const state = await ctx.localControl.getSessionCredentialOverlayState?.();
-                            sessionProviders = state?.providers ?? [];
-                        }
-                        catch {
-                            // Session overlay state not available
-                        }
-                        return {
-                            providers: getHeadlessAuthProviders(),
-                            sessionProviders,
-                        };
-                    },
-                    async login(input) {
-                        return runHeadlessLogin(buildStructuredLoginArgs(input));
-                    },
-                    async logout(input) {
-                        return runHeadlessLogout(buildStructuredLogoutArgs(input));
-                    },
-                    async clearSessionOverlay() {
-                        const result = await ctx.localControl.clearSessionCredentialOverlay?.();
-                        return { providers: result?.providers ?? [] };
-                    },
-                    async importEnvSessionOverlay(input) {
-                        const ENV_VAR_MAP = {
-                            anthropic: ["ANTHROPIC_API_KEY"],
-                            openai: ["OPENAI_API_KEY"],
-                            google: ["GOOGLE_API_KEY", "GEMINI_API_KEY"],
-                            groq: ["GROQ_API_KEY"],
-                            deepseek: ["DEEPSEEK_API_KEY"],
-                            xai: ["XAI_API_KEY"],
-                            mistral: ["MISTRAL_API_KEY"],
-                            openrouter: ["OPENROUTER_API_KEY"],
-                        };
-                        const providers = Array.isArray(input?.providers) && input.providers.length > 0
-                            ? input.providers
-                                .filter((value) => typeof value === "string" && value.trim().length > 0)
-                                .map((value) => value.trim())
-                            : Object.keys(ENV_VAR_MAP);
-                        // Resolve env values in the CLIENT process (where env is available),
-                        // then send explicit credentials to the daemon (whose env is sanitized).
-                        const credentials = [];
-                        for (const provider of providers) {
-                            const normalized = provider.toLowerCase();
-                            const envVars = ENV_VAR_MAP[normalized] ?? [
-                                `${normalized.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_API_KEY`,
-                            ];
-                            for (const envVar of envVars) {
-                                const value = process.env[envVar];
-                                if (typeof value === "string" && value.trim().length > 8) {
-                                    credentials.push({
-                                        provider: normalized,
-                                        apiKey: value.trim(),
-                                        source: "env",
-                                        credentialType: "api_key",
-                                    });
-                                    break;
-                                }
-                            }
-                        }
-                        const result = await ctx.localControl.setSessionCredentialOverlay?.({
-                            credentials,
-                        });
-                        return { providers: result?.providers ?? [] };
-                    },
-                };
-            })(),
-            modelDiscovery: {
-                async listAvailable() {
-                    return availableModels;
-                },
-                async refresh(force) {
-                    availableModels = await activeCli.refreshAvailableModels(force);
-                    return availableModels;
-                },
-                async getCurrentModel() {
-                    if (currentModelName) {
-                        return currentModelName;
-                    }
-                    const currentArion = await arionManager.get(getCurrentArionName());
-                    if (currentArion?.preferredModel) {
-                        currentModelName = currentArion.preferredModel;
-                        return currentModelName;
-                    }
-                    const preferredTier = loadConfig().preferredTier ?? activeCli.config.preferredTier;
-                    if (!preferredTier) {
-                        return availableModels[0]?.shortName;
-                    }
-                    currentModelName =
-                        selectRunnableModelVariant(availableModels.find((candidate) => candidate.tier === preferredTier) ??
-                            availableModels[0], activeCli.credentialHints)?.shortName ?? availableModels[0]?.shortName;
-                    return currentModelName;
-                },
-                async setCurrentModel(model) {
-                    const selectedModel = resolveModelFromCommandArg(model, availableModels, activeCli.credentialHints);
-                    if (!selectedModel) {
-                        throw new Error(`Unknown model: ${model}`);
-                    }
-                    currentModelName = selectedModel.shortName;
-                    const configuredArionName = getCurrentArionName();
-                    const configuredArion = await arionManager.get(configuredArionName);
-                    if (configuredArion) {
-                        await arionManager.setPreferredModel(configuredArionName, selectedModel.shortName);
-                    }
-                    const config = loadConfig();
-                    config.preferredTier = selectedModel.tier;
-                    saveConfig(config);
-                    return {
-                        currentModel: selectedModel.shortName,
-                        tier: selectedModel.tier,
-                    };
-                },
-                async getSessionModel() {
-                    return currentModelName;
-                },
-            },
-            daemon: daemonService,
-            hook: hookService,
-            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(),
-                    };
-                },
-            },
-            getSessionModel: getCurrentModelName,
-            getSessionArion: getCurrentArionName,
-        };
-        const initialConfiguredArion = await arionManager.get(getCurrentArionName());
-        if (initialConfiguredArion?.preferredModel) {
-            currentModelName = initialConfiguredArion.preferredModel;
-        }
-        else {
-            const startupPreferredTier = loadConfig().preferredTier ?? activeCli.config.preferredTier;
-            currentModelName =
-                selectRunnableModelVariant(availableModels.find((candidate) => candidate.tier === startupPreferredTier) ??
-                    availableModels[0], activeCli.credentialHints)?.shortName ?? availableModels[0]?.shortName;
-        }
-        return {
-            kernel: new HeadlessKernel(ctx),
-            ctx,
-            async release() {
-                await releaseResources();
-            },
-        };
-    }
-    catch (error) {
-        try {
-            await releaseResources();
-        }
-        catch (releaseError) {
-            throw new AggregateError([error, releaseError], "Headless kernel bootstrap failed and resource cleanup also failed");
-        }
-        throw error;
-    }
-}
-//# sourceMappingURL=kernel.js.map