@di-code/coding-agent 0.1.6 → 0.1.8

package/dist/main.js

@@ -1,542 +1,159 @@
-import { randomUUID } from "node:crypto";
-import { access, readdir, stat } from "node:fs/promises";
+import { access } from "node:fs/promises";
 import { homedir } from "node:os";
-import { basename, dirname, extname, join, resolve } from "node:path";
-import { ProcessTerminal, TUI, truncateToWidth } from "@di-code/tui";
-import { runCli } from "./cli.js";
-import { loadImageInputs } from "./core/image-input.js";
-import { loadResources } from "./core/resources/loader.js";
-import { SessionManager } from "./core/session/session-manager.js";
-import { AgentSession } from "./core/session.js";
-import { buildSystemPrompt } from "./core/system-prompt.js";
-import { workspaceStorageKey } from "./core/user-data.js";
-import { ProjectTrustManager } from "./extensions/trust.js";
-import { DEFAULT_LOCALE, translate } from "./i18n.js";
-import { addMcpConfig, getMcpConfig, listMcpConfig, removeMcpConfig } from "./mcp/config.js";
-import { loadProjectMcp } from "./mcp/loader.js";
-import { InteractiveMode } from "./modes/interactive.js";
-import { runJsonMode } from "./modes/json.js";
-import { runPrintMode } from "./modes/print.js";
-import { loadPlugins } from "./plugins/loader.js";
-import { PluginManager } from "./plugins/manager.js";
-const MAX_SESSION_QUESTION_LENGTH = 72;
-function defaultSessionDirectory(agentDir, cwd) {
-    return join(agentDir, "sessions", workspaceStorageKey(cwd));
-}
-const STARTUP_STATUS_COLORS = {
-    error: "\x1b[31m",
-    success: "\x1b[32m",
-    warning: "\x1b[33m",
-    reset: "\x1b[0m",
-};
-function formatMcpStatus(status) {
-    switch (status.state) {
-        case "connecting":
-            return `${STARTUP_STATUS_COLORS.warning}MCP [loading]${STARTUP_STATUS_COLORS.reset} ${status.serverId}`;
-        case "connected":
-            return `${STARTUP_STATUS_COLORS.success}MCP [ok]${STARTUP_STATUS_COLORS.reset} ${status.serverId} (${status.tools} tools, ${status.resources} resources, ${status.prompts} prompts)`;
-        case "failed":
-            return `${STARTUP_STATUS_COLORS.error}MCP [error]${STARTUP_STATUS_COLORS.reset} ${status.serverId} (${status.stage}): ${status.message}`;
-    }
-}
-function formatMcpDiagnostic(serverId, stage, message) {
-    return `${STARTUP_STATUS_COLORS.error}MCP [error]${STARTUP_STATUS_COLORS.reset} ${serverId ?? "configuration"} (${stage}): ${message}\n`;
-}
-function formatPluginStatus(status) {
-    switch (status.state) {
-        case "loading":
-            return `${STARTUP_STATUS_COLORS.warning}Plugin [loading]${STARTUP_STATUS_COLORS.reset} ${status.pluginId}`;
-        case "loaded":
-            return `${STARTUP_STATUS_COLORS.success}Plugin [ok]${STARTUP_STATUS_COLORS.reset} ${status.pluginId} (${status.tools} tools, ${status.commands} commands)`;
-        case "failed":
-            return `${STARTUP_STATUS_COLORS.error}Plugin [error]${STARTUP_STATUS_COLORS.reset} ${status.pluginId ?? "plugin"} (${status.stage}): ${status.message}`;
-    }
-}
-function formatPluginDiagnostic(pluginId, stage, message) {
-    return `${STARTUP_STATUS_COLORS.error}Plugin [error]${STARTUP_STATUS_COLORS.reset} ${pluginId ?? "plugin"} (${stage}): ${message}\n`;
-}
-function pluginStatusKey(status) {
-    if (status.state === "failed" && status.pluginId === undefined)
-        return `plugin:${status.sourcePath}`;
-    return `plugin:${status.pluginId}`;
-}
-/** Renders startup states in place so terminal history retains only their final outcome. */
-export class StartupStatusRenderer {
-    lines = [];
-    indexes = new Map();
-    write;
-    replaceInPlace;
-    width;
-    constructor(write, replaceInPlace, width = 80) {
-        this.write = write;
-        this.replaceInPlace = replaceInPlace;
-        this.width = width;
-    }
-    update(key, text) {
-        const line = truncateToWidth(text.replace(/[\r\n]+/g, " "), Math.max(1, this.width), "...");
-        const index = this.indexes.get(key);
-        if (index === undefined || !this.replaceInPlace) {
-            this.indexes.set(key, this.lines.length);
-            this.lines.push(line);
-            this.write(`${line}\n`);
-            return;
-        }
-        this.lines[index] = line;
-        const offset = this.lines.length - index;
-        this.write(`\x1b[${offset}A\r\x1b[2K${line}\x1b[${offset}B\r`);
-    }
-}
-function startupStatusRenderer(write, interactive) {
-    const width = typeof process.stderr.columns === "number" && process.stderr.columns > 0 ? process.stderr.columns : 80;
-    return new StartupStatusRenderer(write, interactive && process.stderr.isTTY === true, width);
-}
-async function openOrCreateSession(filePath, cwd, now) {
-    try {
-        await access(filePath);
-        return await SessionManager.open(filePath, { now });
-    }
-    catch (cause) {
-        if (!(cause instanceof Error && "code" in cause && cause.code === "ENOENT"))
-            throw cause;
-        return SessionManager.create({ filePath, cwd, now, deferCreate: true });
-    }
-}
-function newSessionPath(sessionDirectory, now) {
-    return join(sessionDirectory, `session-${now()}-${randomUUID().slice(0, 8)}.jsonl`);
-}
-async function mostRecentSessionPath(sessionDirectory) {
-    let names;
-    try {
-        names = (await readdir(sessionDirectory, { withFileTypes: true }))
-            .filter((entry) => entry.isFile() && extname(entry.name) === ".jsonl")
-            .map((entry) => entry.name);
-    }
-    catch (cause) {
-        if (cause instanceof Error && "code" in cause && cause.code === "ENOENT")
-            return undefined;
-        throw cause;
-    }
-    const candidates = await Promise.all(names.map(async (name) => {
-        const filePath = join(sessionDirectory, name);
-        try {
-            return { filePath, modifiedAt: (await stat(filePath)).mtimeMs };
-        }
-        catch (cause) {
-            if (cause instanceof Error && "code" in cause && cause.code === "ENOENT")
-                return undefined;
-            throw cause;
-        }
-    }));
-    return candidates
-        .filter((candidate) => candidate !== undefined)
-        .sort((left, right) => right.modifiedAt - left.modifiedAt || right.filePath.localeCompare(left.filePath))[0]
-        ?.filePath;
-}
-async function hasProjectLocalCapabilities(cwd) {
-    const directories = [
+import { join, resolve } from "node:path";
+import { hostCommandRegistryKey, processExitKey, sessionStoreKey } from "@di-code/builtins";
+import { createCompositionLoader } from "@di-code/plugin-loader";
+import { createRootContext, redactSensitiveText } from "@di-code/plugin-runtime";
+import { createCliParser } from "./cli.js";
+import { importCompositionModule, resolveCompositionEntries, resolveManagedCompositionEntries, } from "./compositions.js";
+import { createProjectTrustStore } from "./project-trust-entry.js";
+import { pluginInventoryKey } from "./runtime/plugin-inventory-service.js";
+function errorMessage(cause) {
+    return redactSensitiveText(cause instanceof Error ? cause.message : String(cause));
+}
+function isRun(command) {
+    return command.kind === "run";
+}
+function isMinimalCommand(command) {
+    return command.kind === "run" || command.kind === "plugin" || command.kind === "observe";
+}
+async function hasTrustedProjectContent(cwd) {
+    for (const path of [
         join(cwd, ".di-code", "skills"),
         join(cwd, ".agents", "skills"),
-        join(cwd, ".di-code", "extensions"),
-        join(cwd, ".di-code", "plugins"),
         join(cwd, ".di-code", "mcp.local.json"),
         join(cwd, ".mcp.json"),
-    ];
-    const results = await Promise.all(directories.map(async (directory) => {
+    ]) {
         try {
-            const metadata = await stat(directory);
-            return metadata.isDirectory() || metadata.isFile();
+            await access(path);
+            return true;
         }
         catch (cause) {
-            if (cause instanceof Error && "code" in cause && cause.code === "ENOENT")
-                return false;
-            return false;
+            if (!(cause instanceof Error && "code" in cause && cause.code === "ENOENT"))
+                throw cause;
         }
-    }));
-    return results.some(Boolean);
-}
-async function selectStartupSession(command, allowedRoot, agentDir, now) {
-    const sessionDirectory = defaultSessionDirectory(agentDir, allowedRoot);
-    if (command.sessionPath !== undefined) {
-        return openOrCreateSession(resolve(allowedRoot, command.sessionPath), allowedRoot, now);
-    }
-    if (command.continueSession) {
-        const recentPath = await mostRecentSessionPath(sessionDirectory);
-        if (recentPath !== undefined)
-            return SessionManager.open(recentPath, { now });
     }
-    return SessionManager.create({
-        filePath: newSessionPath(sessionDirectory, now),
-        cwd: allowedRoot,
-        now,
-        deferCreate: true,
-    });
+    return false;
 }
-function formatSessionTimestamp(timestamp, fallback, timeZone) {
-    const date = new Date(timestamp);
-    if (Number.isNaN(date.getTime()))
-        return fallback;
+/** Starts a composition profile and executes its registered host command. */
+export async function runMinimalProfile(args, options) {
+    const parser = createCliParser();
+    let command;
     try {
-        const parts = new Map(new Intl.DateTimeFormat("en-CA", {
-            timeZone: timeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone,
-            year: "numeric",
-            month: "2-digit",
-            day: "2-digit",
-            hour: "2-digit",
-            minute: "2-digit",
-            hourCycle: "h23",
-        })
-            .formatToParts(date)
-            .filter((part) => part.type !== "literal")
-            .map((part) => [part.type, part.value]));
-        const year = parts.get("year");
-        const month = parts.get("month");
-        const day = parts.get("day");
-        const hour = parts.get("hour");
-        const minute = parts.get("minute");
-        if (!year || !month || !day || !hour || !minute)
-            return fallback;
-        return `${year}-${month}-${day} ${hour}:${minute}`;
+        command = parser.parse(args);
     }
-    catch {
-        return fallback;
+    catch (cause) {
+        options.stderr(`${errorMessage(cause)}\n`);
+        return 1;
     }
-}
-export function formatSessionLabel(manager, timeZone) {
-    const firstUserEntry = manager.entries.find((entry) => entry.type === "message" && entry.message.role === "user");
-    const fileName = basename(manager.filePath, extname(manager.filePath));
-    if (firstUserEntry?.type !== "message" || firstUserEntry.message.role !== "user") {
-        return `${fileName} (${formatSessionTimestamp(Date.parse(manager.header.timestamp), manager.header.timestamp, timeZone)})`;
+    if (command.kind === "help") {
+        options.stdout(`${parser.help("en")}\n`);
+        return 0;
     }
-    const question = firstUserEntry.message.content
-        .filter((content) => content.type === "text")
-        .map((content) => content.text)
-        .join(" ")
-        .replace(/\s+/g, " ")
-        .trim();
-    const label = question.length > MAX_SESSION_QUESTION_LENGTH
-        ? `${question.slice(0, MAX_SESSION_QUESTION_LENGTH - 3)}...`
-        : question || fileName;
-    const timestamp = formatSessionTimestamp(firstUserEntry.message.timestamp, firstUserEntry.timestamp, timeZone);
-    return `${label} (${timestamp})`;
-}
-async function sessionChoices(sessionDirectory, currentFile, open) {
-    let names = [];
-    try {
-        names = (await readdir(sessionDirectory, { withFileTypes: true }))
-            .filter((entry) => entry.isFile() && extname(entry.name) === ".jsonl")
-            .map((entry) => entry.name)
-            .sort();
+    if (command.kind === "version") {
+        options.stdout(`${options.version}\n`);
+        return 0;
     }
-    catch (cause) {
-        if (!(cause instanceof Error && "code" in cause && cause.code === "ENOENT"))
-            throw cause;
+    if (!isMinimalCommand(command)) {
+        options.stderr("MCP commands are unavailable in the minimal profile.\n");
+        return 1;
     }
-    return Promise.all(names
-        .filter((name) => resolve(sessionDirectory, name) !== resolve(currentFile))
-        .map(async (name) => {
-        const filePath = join(sessionDirectory, name);
-        const id = basename(name, extname(name));
-        let label = id;
-        try {
-            label = formatSessionLabel(await SessionManager.open(filePath));
+    if (isRun(command) && command.mode === "interactive" && !options.interactive?.isInteractiveTerminal) {
+        options.stderr("Interactive mode requires an interactive TTY.\n");
+        return 1;
+    }
+    const mode = isRun(command) ? command.mode : "print";
+    const observability = command.kind === "observe";
+    const allowedRoot = resolve(options.allowedRoot ?? process.cwd());
+    const agentDir = resolve(options.agentDir ?? join(homedir(), ".di-code"));
+    const trustStore = createProjectTrustStore(join(agentDir, "trust.json"));
+    if (isRun(command) && command.projectTrust !== undefined)
+        await trustStore.set(allowedRoot, command.projectTrust);
+    let projectTrusted = isRun(command) && !command.noProjectPlugins && (await trustStore.get(allowedRoot)) === true;
+    if (isRun(command) &&
+        command.mode === "interactive" &&
+        !projectTrusted &&
+        command.projectTrust === undefined &&
+        options.interactive?.promptProjectTrust &&
+        (await hasTrustedProjectContent(allowedRoot))) {
+        projectTrusted = await options.interactive.promptProjectTrust(allowedRoot);
+        await trustStore.set(allowedRoot, projectTrusted);
+    }
+    const managedEntries = await resolveManagedCompositionEntries(agentDir);
+    const compositionEntries = await resolveCompositionEntries(isRun(command) ? (command.profile ?? command.mode) : "base", {
+        cwd: allowedRoot,
+        agentDir,
+        ...(isRun(command) && command.compositionPath ? { compositionPath: command.compositionPath } : {}),
+        includeProjectComposition: projectTrusted,
+        observability,
+        allowedRoot,
+    });
+    const context = createRootContext({ id: "minimal-profile", mode, trustedProject: projectTrusted });
+    const unsubscribe = context.events.subscribe((event) => options.onRuntimeEvent?.(event));
+    const loader = createCompositionLoader({
+        context,
+        entries: [...compositionEntries, ...managedEntries],
+        importModule: options.importModule ?? importCompositionModule,
+        projectTrusted,
+    });
+    try {
+        await loader.load();
+        context.require(pluginInventoryKey).set(loader.tree.snapshot());
+        const host = context.require(hostCommandRegistryKey);
+        let name;
+        let input;
+        if (command.kind === "observe") {
+            name = command.action === "trace" ? "trace-plugins" : "dump-composition";
+            input = { stdout: options.stdout };
         }
-        catch {
-            // Keep damaged sessions selectable so opening one can report the detailed load error.
+        else if (command.kind === "plugin") {
+            name = "plugin";
+            input = { ...command, stdout: options.stdout, stderr: options.stderr };
         }
-        return {
-            id,
-            label,
-            description: filePath,
-            open: () => open(filePath),
-        };
-    }));
-}
-export async function runMain(args, options) {
-    const dependencies = {
-        stdout: options.stdout,
-        stderr: options.stderr,
-        version: options.version,
-        locale: options.locale ?? options.startupConfiguration?.locale ?? DEFAULT_LOCALE,
-        plugin: async (command) => {
-            const agentDir = resolve(options.agentDir ?? join(homedir(), ".di-code"));
-            const manager = new PluginManager({ agentDir });
-            try {
-                switch (command.action) {
-                    case "list":
-                        for (const plugin of await manager.list())
-                            options.stdout(`${plugin.id}\t${plugin.enabled ? "enabled" : "disabled"}\t${plugin.manifest.version}\n`);
-                        return 0;
-                    case "install": {
-                        const plugin = await manager.install(command.argument);
-                        options.stdout(`Installed ${plugin.id}\n`);
-                        return 0;
-                    }
-                    case "enable":
-                        await manager.enable(command.argument);
-                        return 0;
-                    case "disable":
-                        await manager.disable(command.argument);
-                        return 0;
-                    case "update":
-                        await manager.update(command.argument);
-                        return 0;
-                    case "remove":
-                        await manager.remove(command.argument);
-                        return 0;
-                }
-            }
-            catch (cause) {
-                options.stderr(`${cause instanceof Error ? cause.message : String(cause)}\n`);
-                return 1;
-            }
-        },
-        mcp: async (command) => {
-            const cwd = resolve(options.allowedRoot ?? process.cwd());
-            const scope = command.scope;
-            const trustManager = new ProjectTrustManager(join(options.agentDir ?? join(homedir(), ".di-code"), "trust.json"));
-            const requireProjectTrust = async (selected) => {
-                if ((selected === "local" || selected === "project") && (await trustManager.get(cwd)) !== true)
-                    throw new Error(`Project trust is required to modify the ${selected} MCP scope.`);
-            };
-            try {
-                switch (command.action) {
-                    case "add": {
-                        const selected = scope ?? "local";
-                        await requireProjectTrust(selected);
-                        const config = command.transport === "stdio"
-                            ? {
-                                command: command.command,
-                                ...(command.args && command.args.length > 0 ? { args: command.args } : {}),
-                            }
-                            : { type: "http", url: command.url };
-                        await addMcpConfig(cwd, selected, command.serverId, config);
-                        options.stdout(`Added MCP server "${command.serverId}" to ${selected} scope.\n`);
-                        return 0;
-                    }
-                    case "list": {
-                        const scopes = scope ? [scope] : ["local", "project", "user"];
-                        for (const selected of scopes) {
-                            for (const entry of await listMcpConfig(cwd, selected))
-                                options.stdout(`${entry.id}\t${entry.scope}\t${JSON.stringify(entry.config)}\n`);
-                        }
-                        return 0;
-                    }
-                    case "get": {
-                        const entry = await getMcpConfig(cwd, command.serverId, scope);
-                        if (!entry)
-                            throw new Error(`MCP server "${command.serverId}" was not found.`);
-                        options.stdout(`${JSON.stringify({ id: entry.id, scope: entry.scope, config: entry.config })}\n`);
-                        return 0;
-                    }
-                    case "remove": {
-                        const selected = scope ?? "local";
-                        await requireProjectTrust(selected);
-                        await removeMcpConfig(cwd, selected, command.serverId);
-                        options.stdout(`Removed MCP server "${command.serverId}" from ${selected} scope.\n`);
-                        return 0;
-                    }
-                }
-            }
-            catch (cause) {
-                options.stderr(`${cause instanceof Error ? cause.message : String(cause)}\n`);
-                return 1;
-            }
-        },
-        run: async (command) => {
-            const allowedRoot = resolve(options.allowedRoot ?? process.cwd());
-            const now = options.now ?? Date.now;
-            const agentDir = resolve(options.agentDir ?? join(homedir(), ".di-code"));
-            const trustManager = new ProjectTrustManager(join(agentDir, "trust.json"));
-            if (command.projectTrust !== undefined)
-                await trustManager.set(allowedRoot, command.projectTrust);
-            let persistedTrust = await trustManager.get(allowedRoot);
-            const shouldPromptForTrust = command.mode === "interactive" &&
-                options.isInteractiveTerminal === true &&
-                command.projectTrust === undefined &&
-                persistedTrust === null &&
-                options.promptProjectTrust !== undefined &&
-                (await hasProjectLocalCapabilities(allowedRoot));
-            if (shouldPromptForTrust) {
-                let decision = false;
-                try {
-                    decision = await options.promptProjectTrust(allowedRoot);
-                }
-                catch {
-                    // Fail closed when the prompt is interrupted or unavailable.
-                }
-                await trustManager.set(allowedRoot, decision);
-                persistedTrust = decision;
-            }
-            const runtime = await options.createRuntime(command);
-            if (runtime === undefined)
-                return 0;
-            const resources = await loadResources({
-                cwd: allowedRoot,
-                agentDir,
-                projectTrusted: persistedTrust === true,
-                noSkills: command.noSkills,
-                noContextFiles: command.noContextFiles,
-                skillPaths: command.skillPaths,
-            });
-            for (const diagnostic of resources.diagnostics) {
-                if (diagnostic.kind !== "skill")
-                    continue;
-                options.stderr(`${JSON.stringify({ type: "skill_diagnostic", path: diagnostic.path, stage: diagnostic.stage, severity: diagnostic.severity, message: diagnostic.message })}\n`);
-            }
-            const interactivePluginStatus = command.mode === "interactive";
-            const startupStatus = startupStatusRenderer(options.stderr, interactivePluginStatus);
-            const pluginStatusFailures = new Set();
-            const extensions = await loadPlugins({
+        else if (command.mode === "interactive") {
+            name = "interactive";
+            input = {
+                command,
                 cwd: allowedRoot,
                 agentDir,
-                trustManager,
-                mode: command.mode,
-                ...(interactivePluginStatus
-                    ? {
-                        onPluginLoadStatus: (status) => {
-                            if (status.state === "failed")
-                                pluginStatusFailures.add(status.sourcePath);
-                            startupStatus.update(pluginStatusKey(status), formatPluginStatus(status));
-                        },
-                    }
-                    : {}),
-            });
-            for (const diagnostic of extensions.diagnostics) {
-                if (interactivePluginStatus) {
-                    if (pluginStatusFailures.has(diagnostic.sourcePath))
-                        continue;
-                    options.stderr(formatPluginDiagnostic(diagnostic.pluginId, diagnostic.stage, diagnostic.message));
-                    continue;
-                }
-                options.stderr(`${JSON.stringify({ type: "plugin_diagnostic", pluginId: diagnostic.pluginId, stage: diagnostic.stage, sourcePath: diagnostic.sourcePath, severity: diagnostic.severity, message: diagnostic.message })}\n`);
-            }
-            const interactiveMcpStatus = command.mode === "interactive";
-            const mcp = await loadProjectMcp({
-                cwd: allowedRoot,
-                projectTrusted: persistedTrust === true,
-                homeDirectory: homedir(),
-                reservedToolNames: [
-                    "read",
-                    "write",
-                    "edit",
-                    "bash",
-                    "load_skill",
-                    ...extensions.host.listTools().map((tool) => tool.name),
-                ],
-                ...(interactiveMcpStatus
-                    ? {
-                        onServerConnectionStatus: (status) => startupStatus.update(`mcp:${status.serverId}`, formatMcpStatus(status)),
-                    }
+                projectTrusted,
+                stderr: options.stderr,
+                ...(options.interactive?.startInteractiveMode
+                    ? { startInteractiveMode: options.interactive.startInteractiveMode }
                     : {}),
-            });
-            for (const diagnostic of mcp.diagnostics) {
-                if (interactiveMcpStatus) {
-                    if (diagnostic.serverId && (diagnostic.stage === "connect" || diagnostic.stage === "list_tools"))
-                        continue;
-                    options.stderr(formatMcpDiagnostic(diagnostic.serverId, diagnostic.stage, diagnostic.message));
-                    continue;
-                }
-                options.stderr(`${JSON.stringify({ type: "mcp_diagnostic", serverId: diagnostic.serverId, stage: diagnostic.stage, message: diagnostic.message })}\n`);
-            }
-            const systemPrompt = buildSystemPrompt({ cwd: allowedRoot, ...resources });
-            const manager = await selectStartupSession(command, allowedRoot, agentDir, now);
-            const sessionFile = manager.filePath;
-            const session = new AgentSession({
-                allowedRoot,
-                provider: runtime.provider,
-                model: runtime.model,
-                systemPrompt,
-                skills: resources.skills,
-                now: options.now,
-                sessionManager: manager,
-                extensionHost: extensions.host,
-                externalTools: mcp.tools,
-            });
-            const imagePaths = command.imagePaths ?? [];
-            const promptRunner = {
-                prompt: async (text) => session.promptWithImages(text, await loadImageInputs(imagePaths, allowedRoot)),
-                subscribe: session.subscribe.bind(session),
             };
-            if (command.mode === "json") {
-                await extensions.host.emit({ type: "session_start", cwd: allowedRoot });
-                try {
-                    return await runJsonMode(command.prompt, promptRunner, options);
-                }
-                finally {
-                    await extensions.host.emit({ type: "session_shutdown", reason: "user" });
-                    await mcp.manager.close();
-                }
-            }
-            if (command.mode === "interactive") {
-                const terminal = new ProcessTerminal();
-                const tui = new TUI(terminal);
-                const mode = new InteractiveMode({
-                    session,
-                    tui,
-                    agentDir,
-                    locale: options.locale ?? options.startupConfiguration?.locale ?? DEFAULT_LOCALE,
-                    onExit: () => {
-                        void mcp.manager.close();
-                    },
-                    extensionHost: extensions.host,
-                    ...(options.startupConfiguration
-                        ? { providerOnboarding: { configuration: options.startupConfiguration, agentDir } }
-                        : {}),
-                    sessions: [
-                        {
-                            id: "new-session",
-                            label: translate(options.locale ?? options.startupConfiguration?.locale ?? DEFAULT_LOCALE, "newSession"),
-                            description: translate(options.locale ?? options.startupConfiguration?.locale ?? DEFAULT_LOCALE, "newSessionDescription"),
-                            open: async () => {
-                                const filePath = newSessionPath(dirname(sessionFile), now);
-                                const nextManager = await SessionManager.create({
-                                    filePath,
-                                    cwd: allowedRoot,
-                                    now,
-                                    deferCreate: true,
-                                });
-                                return new AgentSession({
-                                    allowedRoot,
-                                    provider: runtime.provider,
-                                    model: runtime.model,
-                                    systemPrompt,
-                                    skills: resources.skills,
-                                    now: options.now,
-                                    sessionManager: nextManager,
-                                    extensionHost: extensions.host,
-                                    externalTools: mcp.tools,
-                                });
-                            },
-                        },
-                        ...(await sessionChoices(dirname(sessionFile), sessionFile, async (filePath) => {
-                            const nextManager = await SessionManager.open(filePath, { now });
-                            return new AgentSession({
-                                allowedRoot,
-                                provider: runtime.provider,
-                                model: runtime.model,
-                                systemPrompt,
-                                skills: resources.skills,
-                                now: options.now,
-                                sessionManager: nextManager,
-                                extensionHost: extensions.host,
-                                externalTools: mcp.tools,
-                            });
-                        })),
-                    ],
-                });
-                mode.start(command.prompt);
-                return 0;
-            }
-            await extensions.host.emit({ type: "session_start", cwd: allowedRoot });
+        }
+        else {
+            name = command.mode;
+            input = { prompt: command.prompt, stdout: options.stdout };
+        }
+        const code = await host.execute(name, input, context.signal);
+        const processExit = context.require(processExitKey);
+        processExit.setCode(code);
+        return processExit.code();
+    }
+    catch (cause) {
+        options.stderr(`${errorMessage(cause).replace(/^Required entry agent-loop failed: /, "")}\n`);
+        return 1;
+    }
+    finally {
+        const memory = context.get(sessionStoreKey);
+        try {
             try {
-                return await runPrintMode(command.prompt, promptRunner, options);
+                await loader.dispose();
             }
             finally {
-                await extensions.host.emit({ type: "session_shutdown", reason: "user" });
-                await mcp.manager.close();
+                await context.dispose();
             }
-        },
-    };
-    return runCli(args, dependencies);
+        }
+        finally {
+            unsubscribe();
+            if (memory) {
+                memory.dispose();
+                if (memory.disposed())
+                    options.onSessionDisposed?.();
+            }
+        }
+    }
 }
 //# sourceMappingURL=main.js.map