@selesai/code 0.13.12 → 0.13.13

package/dist/main.js

@@ -1,768 +0,0 @@
-/**
- * Main entry point for the coding agent CLI.
- *
- * This file handles CLI argument parsing and translates them into
- * createAgentSession() options. The SDK does the heavy lifting.
- */
-import { createInterface } from "node:readline";
-import { modelsAreEqual } from "@earendil-works/pi-ai";
-import { setCapabilityOverrides } from "@earendil-works/pi-tui";
-import chalk from "chalk";
-import { parseArgs, printHelp } from "./cli/args.js";
-import { CredentialPrintError, isCredentialPrintHelp, parseCredentialPrintCommand, printCredentialPrintHelp, resolveCredentialForPrint, validateCredentialPrintArgs, } from "./cli/credential-print.js";
-import { processFileArguments } from "./cli/file-processor.js";
-import { buildInitialMessage } from "./cli/initial-message.js";
-import { listModels } from "./cli/list-models.js";
-import { createProjectTrustContext } from "./cli/project-trust.js";
-import { selectSession } from "./cli/session-picker.js";
-import { shouldRunFirstTimeSetup, showFirstTimeSetup, showStartupSelector } from "./cli/startup-ui.js";
-import { bootstrapAgentDir, ENV_SESSION_DIR, expandTildePath, getAgentDir, getBundledExtensionsDir, getBundledSkillsDir, getBundledThemesDir, getPackageDir, VERSION } from "./config.js";
-import { createAgentSessionRuntime } from "./core/agent-session-runtime.js";
-import { createAgentSessionFromServices, createAgentSessionServices, } from "./core/agent-session-services.js";
-import { formatNoModelsAvailableMessage } from "./core/auth-guidance.js";
-import { exportFromFile } from "./core/export-html/index.js";
-import { applyHttpProxySettings, configureHttpDispatcher } from "./core/http-dispatcher.js";
-import { resolveCliModel, resolveModelScope } from "./core/model-resolver.js";
-import { ModelRuntime } from "./core/model-runtime.js";
-import { restoreStdout, takeOverStdout } from "./core/output-guard.js";
-import { resolveProjectTrusted } from "./core/project-trust.js";
-import { formatMissingSessionCwdPrompt, getMissingSessionCwdIssue, MissingSessionCwdError, } from "./core/session-cwd.js";
-import { assertValidSessionId, SessionManager } from "./core/session-manager.js";
-import { SettingsManager } from "./core/settings-manager.js";
-import { printTimings, resetTimings, time } from "./core/timings.js";
-import { hasTrustRequiringProjectResources, ProjectTrustStore } from "./core/trust-manager.js";
-import { builtInExtensions } from "./core/built-in-extensions.js";
-import { runMigrations, showDeprecationWarnings } from "./migrations.js";
-import { InteractiveMode, runPrintMode, runRpcMode } from "./modes/index.js";
-import { initTheme, stopThemeWatcher } from "./modes/interactive/theme/theme.js";
-import { handleConfigCommand, handlePackageCommand } from "./package-manager-cli.js";
-import { isLocalPath, normalizePath, resolvePath } from "./utils/paths.js";
-import { cleanupWindowsSelfUpdateQuarantine } from "./utils/windows-self-update.js";
-const EXTENSION_LOAD_FAILURE_HINT = 'Hint: Start without extensions using "selesai -ne".';
-/**
- * Read all content from piped stdin.
- * Returns undefined if stdin is a TTY (interactive terminal).
- */
-async function readPipedStdin() {
-    // If stdin is a TTY, we're running interactively - don't read stdin
-    if (process.stdin.isTTY) {
-        return undefined;
-    }
-    return new Promise((resolve) => {
-        let data = "";
-        process.stdin.setEncoding("utf8");
-        process.stdin.on("data", (chunk) => {
-            data += chunk;
-        });
-        process.stdin.on("end", () => {
-            resolve(data.trim() || undefined);
-        });
-        process.stdin.resume();
-    });
-}
-function collectSettingsDiagnostics(settingsManager, context) {
-    return settingsManager.drainErrors().map(({ scope, error }) => ({
-        type: "warning",
-        message: `(${context}, ${scope} settings) ${error.message}`,
-    }));
-}
-function reportDiagnostics(diagnostics) {
-    for (const diagnostic of diagnostics) {
-        const color = diagnostic.type === "error" ? chalk.red : diagnostic.type === "warning" ? chalk.yellow : chalk.dim;
-        const prefix = diagnostic.type === "error" ? "Error: " : diagnostic.type === "warning" ? "Warning: " : "";
-        console.error(color(`${prefix}${diagnostic.message}`));
-    }
-}
-function isTruthyEnvFlag(value) {
-    if (!value)
-        return false;
-    return value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes";
-}
-function resolveAppMode(parsed, stdinIsTTY, stdoutIsTTY) {
-    if (parsed.mode === "rpc") {
-        return "rpc";
-    }
-    if (parsed.mode === "json") {
-        return "json";
-    }
-    if (parsed.print || !stdinIsTTY || !stdoutIsTTY) {
-        return "print";
-    }
-    return "interactive";
-}
-function toPrintOutputMode(appMode) {
-    return appMode === "json" ? "json" : "text";
-}
-function isPlainRuntimeMetadataCommand(parsed) {
-    return !parsed.print && parsed.mode === undefined && (parsed.help === true || parsed.listModels !== undefined);
-}
-async function runCredentialPrintCommand(args) {
-    if (isCredentialPrintHelp(args)) {
-        printCredentialPrintHelp();
-        return true;
-    }
-    let command;
-    try {
-        command = parseCredentialPrintCommand(args);
-    }
-    catch (error) {
-        const message = error instanceof CredentialPrintError ? error.message : "Failed to parse auth command";
-        console.error(chalk.red(`Error: ${message}`));
-        process.exitCode = 1;
-        return true;
-    }
-    if (!command)
-        return false;
-    const parsed = parseArgs(command.args);
-    if (parsed.diagnostics.length > 0) {
-        for (const diagnostic of parsed.diagnostics) {
-            console.error(chalk.red(`Error: ${diagnostic.message}`));
-        }
-        process.exitCode = 1;
-        return true;
-    }
-    try {
-        validateCredentialPrintArgs(parsed);
-        const modelRuntime = await ModelRuntime.create({ allowModelNetwork: false });
-        const credential = await resolveCredentialForPrint(parsed, modelRuntime, command.kind, command.minExpiryMs);
-        process.stdout.write(`${credential}\n`);
-    }
-    catch (error) {
-        const message = error instanceof CredentialPrintError ? error.message : "Failed to resolve credential";
-        console.error(chalk.red(`Error: ${message}`));
-        process.exitCode = 1;
-    }
-    return true;
-}
-async function prepareInitialMessage(parsed, autoResizeImages, stdinContent) {
-    if (parsed.fileArgs.length === 0) {
-        return buildInitialMessage({ parsed, stdinContent });
-    }
-    const { text, images } = await processFileArguments(parsed.fileArgs, { autoResizeImages });
-    return buildInitialMessage({
-        parsed,
-        fileText: text,
-        fileImages: images,
-        stdinContent,
-    });
-}
-/**
- * Resolve a session argument to a file path.
- * If it looks like a path, use as-is. Otherwise try to match as session ID prefix.
- */
-async function findLocalSessionByExactId(sessionId, cwd, sessionDir) {
-    const localSessions = await SessionManager.list(cwd, sessionDir);
-    const localMatch = localSessions.find((s) => s.id === sessionId);
-    return localMatch ? { type: "local", path: localMatch.path } : undefined;
-}
-async function resolveSessionPath(sessionArg, cwd, sessionDir) {
-    // If it looks like a file path, resolve it before handing it to the session manager.
-    if (sessionArg.includes("/") || sessionArg.includes("\\") || sessionArg.endsWith(".jsonl")) {
-        return { type: "path", path: resolvePath(sessionArg, cwd) };
-    }
-    // Try to match as session ID in current project first
-    const localSessions = await SessionManager.list(cwd, sessionDir);
-    const localMatch = localSessions.find((s) => s.id === sessionArg) ?? localSessions.find((s) => s.id.startsWith(sessionArg));
-    if (localMatch) {
-        return { type: "local", path: localMatch.path };
-    }
-    // Try global search across all projects
-    const allSessions = await SessionManager.listAll(sessionDir);
-    const globalMatch = allSessions.find((s) => s.id === sessionArg) ?? allSessions.find((s) => s.id.startsWith(sessionArg));
-    if (globalMatch) {
-        return { type: "global", path: globalMatch.path, cwd: globalMatch.cwd };
-    }
-    // Not found anywhere
-    return { type: "not_found", arg: sessionArg };
-}
-/** Prompt user for yes/no confirmation */
-async function promptConfirm(message) {
-    return new Promise((resolve) => {
-        const rl = createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        rl.question(`${message} [y/N] `, (answer) => {
-            rl.close();
-            resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
-        });
-    });
-}
-function validateForkFlags(parsed) {
-    if (!parsed.fork)
-        return;
-    const conflictingFlags = [
-        parsed.session ? "--session" : undefined,
-        parsed.continue ? "--continue" : undefined,
-        parsed.resume ? "--resume" : undefined,
-        parsed.noSession ? "--no-session" : undefined,
-    ].filter((flag) => flag !== undefined);
-    if (conflictingFlags.length > 0) {
-        console.error(chalk.red(`Error: --fork cannot be combined with ${conflictingFlags.join(", ")}`));
-        process.exit(1);
-    }
-}
-function validateSessionIdFlags(parsed) {
-    if (parsed.sessionId === undefined)
-        return;
-    const conflictingFlags = [
-        parsed.session ? "--session" : undefined,
-        parsed.continue ? "--continue" : undefined,
-        parsed.resume ? "--resume" : undefined,
-    ].filter((flag) => flag !== undefined);
-    if (conflictingFlags.length > 0) {
-        console.error(chalk.red(`Error: --session-id cannot be combined with ${conflictingFlags.join(", ")}`));
-        process.exit(1);
-    }
-    try {
-        assertValidSessionId(parsed.sessionId);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(chalk.red(`Error: ${message}`));
-        process.exit(1);
-    }
-}
-function openSessionOrExit(path, sessionDir) {
-    try {
-        return SessionManager.open(path, sessionDir);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(chalk.red(`Error: ${message}`));
-        process.exit(1);
-    }
-}
-function forkSessionOrExit(sourcePath, cwd, sessionDir, sessionId) {
-    try {
-        return SessionManager.forkFrom(sourcePath, cwd, sessionDir, { id: sessionId });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(chalk.red(`Error: ${message}`));
-        process.exit(1);
-    }
-}
-async function createSessionManager(parsed, cwd, sessionDir, settingsManager) {
-    if (parsed.noSession || parsed.help || parsed.listModels !== undefined) {
-        return SessionManager.inMemory(cwd, parsed.sessionId !== undefined ? { id: parsed.sessionId } : undefined);
-    }
-    if (parsed.fork) {
-        if (parsed.sessionId) {
-            const existingTarget = await findLocalSessionByExactId(parsed.sessionId, cwd, sessionDir);
-            if (existingTarget) {
-                console.error(chalk.red(`Session already exists with id '${parsed.sessionId}'`));
-                process.exit(1);
-            }
-        }
-        const resolved = await resolveSessionPath(parsed.fork, cwd, sessionDir);
-        switch (resolved.type) {
-            case "path":
-            case "local":
-            case "global":
-                return forkSessionOrExit(resolved.path, cwd, sessionDir, parsed.sessionId);
-            case "not_found":
-                console.error(chalk.red(`No session found matching '${resolved.arg}'`));
-                process.exit(1);
-        }
-    }
-    if (parsed.session) {
-        const resolved = await resolveSessionPath(parsed.session, cwd, sessionDir);
-        switch (resolved.type) {
-            case "path":
-            case "local":
-                return openSessionOrExit(resolved.path, sessionDir);
-            case "global": {
-                console.log(chalk.yellow(`Session found in different project: ${resolved.cwd}`));
-                const shouldFork = await promptConfirm("Fork this session into current directory?");
-                if (!shouldFork) {
-                    console.log(chalk.dim("Aborted."));
-                    process.exit(0);
-                }
-                return forkSessionOrExit(resolved.path, cwd, sessionDir);
-            }
-            case "not_found":
-                console.error(chalk.red(`No session found matching '${resolved.arg}'`));
-                process.exit(1);
-        }
-    }
-    if (parsed.resume) {
-        try {
-            const selectedPath = await selectSession((onProgress) => SessionManager.list(cwd, sessionDir, onProgress), (onProgress) => SessionManager.listAll(sessionDir, onProgress), settingsManager);
-            if (!selectedPath) {
-                console.log(chalk.dim("No session selected"));
-                process.exit(0);
-            }
-            return SessionManager.open(selectedPath, sessionDir);
-        }
-        finally {
-            stopThemeWatcher();
-        }
-    }
-    if (parsed.continue) {
-        return SessionManager.continueRecent(cwd, sessionDir);
-    }
-    if (parsed.sessionId) {
-        const existingSession = await findLocalSessionByExactId(parsed.sessionId, cwd, sessionDir);
-        if (existingSession) {
-            return SessionManager.open(existingSession.path, sessionDir);
-        }
-        console.error(chalk.yellow(`Warning: No project session found with id '${parsed.sessionId}'; creating a new session with that id.`));
-    }
-    return SessionManager.create(cwd, sessionDir, { id: parsed.sessionId });
-}
-function buildSessionOptions(parsed, scopedModels, hasExistingSession, modelRuntime, settingsManager) {
-    const options = {};
-    const diagnostics = [];
-    let cliThinkingFromModel = false;
-    // Model from CLI
-    // - supports --provider <name> --model <pattern>
-    // - supports --model <provider>/<pattern>
-    if (parsed.model) {
-        const resolved = resolveCliModel({
-            cliProvider: parsed.provider,
-            cliModel: parsed.model,
-            cliThinking: parsed.thinking,
-            modelRuntime,
-        });
-        if (resolved.warning) {
-            diagnostics.push({ type: "warning", message: resolved.warning });
-        }
-        if (resolved.error) {
-            diagnostics.push({ type: "error", message: resolved.error });
-        }
-        if (resolved.model) {
-            options.model = resolved.model;
-            // Allow "--model <pattern>:<thinking>" as a shorthand.
-            // Explicit --thinking still takes precedence (applied later).
-            if (!parsed.thinking && resolved.thinkingLevel) {
-                options.thinkingLevel = resolved.thinkingLevel;
-                cliThinkingFromModel = true;
-            }
-        }
-    }
-    if (!options.model && scopedModels.length > 0 && !hasExistingSession) {
-        // Check if saved default is in scoped models - use it if so, otherwise first scoped model
-        const savedProvider = settingsManager.getDefaultProvider();
-        const savedModelId = settingsManager.getDefaultModel();
-        const savedModel = savedProvider && savedModelId ? modelRuntime.getModel(savedProvider, savedModelId) : undefined;
-        const savedInScope = savedModel ? scopedModels.find((sm) => modelsAreEqual(sm.model, savedModel)) : undefined;
-        if (savedInScope) {
-            options.model = savedInScope.model;
-            // Use thinking level from scoped model config if explicitly set
-            if (!parsed.thinking && savedInScope.thinkingLevel) {
-                options.thinkingLevel = savedInScope.thinkingLevel;
-            }
-        }
-        else {
-            options.model = scopedModels[0].model;
-            // Use thinking level from first scoped model if explicitly set
-            if (!parsed.thinking && scopedModels[0].thinkingLevel) {
-                options.thinkingLevel = scopedModels[0].thinkingLevel;
-            }
-        }
-    }
-    // Thinking level from CLI (takes precedence over scoped model thinking levels set above)
-    if (parsed.thinking) {
-        options.thinkingLevel = parsed.thinking;
-    }
-    // Scoped models for Ctrl+P cycling
-    // Keep thinking level undefined when not explicitly set in the model pattern.
-    // Undefined means "inherit current session thinking level" during cycling.
-    if (scopedModels.length > 0) {
-        options.scopedModels = scopedModels.map((sm) => ({
-            model: sm.model,
-            thinkingLevel: sm.thinkingLevel,
-        }));
-    }
-    // API key from CLI - set as a non-persistent runtime override
-    // (handled by caller before createAgentSession)
-    // Tools
-    if (parsed.noTools) {
-        options.noTools = "all";
-    }
-    else if (parsed.noBuiltinTools) {
-        options.noTools = "builtin";
-    }
-    if (parsed.tools) {
-        options.tools = [...parsed.tools];
-    }
-    if (parsed.excludeTools) {
-        options.excludeTools = [...parsed.excludeTools];
-    }
-    return { options, cliThinkingFromModel, diagnostics };
-}
-function resolveCliPaths(cwd, paths) {
-    return paths?.map((value) => (isLocalPath(value) ? resolvePath(value, cwd) : value));
-}
-async function promptForMissingSessionCwd(issue, settingsManager) {
-    return showStartupSelector(settingsManager, formatMissingSessionCwdPrompt(issue), [
-        { label: "Continue", value: issue.fallbackCwd },
-        { label: "Cancel", value: undefined },
-    ]);
-}
-export async function main(args, options) {
-    resetTimings();
-    const extensionFactories = [...builtInExtensions, ...(options?.extensionFactories ?? [])];
-    const offlineMode = args.includes("--offline") || isTruthyEnvFlag(process.env.PI_OFFLINE);
-    if (offlineMode) {
-        process.env.PI_OFFLINE = "1";
-        process.env.PI_SKIP_VERSION_CHECK = "1";
-    }
-    if (process.platform === "win32") {
-        cleanupWindowsSelfUpdateQuarantine(getPackageDir());
-    }
-    const cwd = process.cwd();
-    const agentDir = getAgentDir();
-    // ponytail: bootstrap on every startup — ensureAgentDir + seed bundled
-    // settings/skills/themes are idempotent (no-op if present). Models/extensions
-    // stay package-local.
-    // Seeding before SettingsManager.create so the first load reads the seeded
-    // defaults instead of starting from an empty {} and skipping first-run UX.
-    bootstrapAgentDir(agentDir);
-    const bootstrapSettingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted: false });
-    applyHttpProxySettings(bootstrapSettingsManager.getGlobalSettings().httpProxy);
-    configureHttpDispatcher();
-    if (await handlePackageCommand(args, { extensionFactories })) {
-        const exitCode = process.exitCode ?? 0;
-        if (process.platform === "win32" && exitCode === 0 && args[0] === "update") {
-            // We normally prefer process.exit(0) for package commands so bad extensions cannot keep
-            // one-shot commands alive. On Windows, Node can assert after fetch() if process.exit(0)
-            // runs during teardown; let successful `pi update` drain naturally instead.
-            // https://github.com/nodejs/node/issues/56645
-            return;
-        }
-        process.exit(exitCode);
-        return;
-    }
-    if (await handleConfigCommand(args, { extensionFactories })) {
-        return;
-    }
-    if (await runCredentialPrintCommand(args)) {
-        return;
-    }
-    const parsed = parseArgs(args);
-    if (parsed.diagnostics.length > 0) {
-        for (const d of parsed.diagnostics) {
-            const color = d.type === "error" ? chalk.red : chalk.yellow;
-            console.error(color(`${d.type === "error" ? "Error" : "Warning"}: ${d.message}`));
-        }
-        if (parsed.diagnostics.some((d) => d.type === "error")) {
-            process.exit(1);
-        }
-    }
-    time("parseArgs");
-    if (parsed.version) {
-        console.log(VERSION);
-        process.exit(0);
-    }
-    if (parsed.export) {
-        let result;
-        try {
-            const outputPath = parsed.messages.length > 0 ? parsed.messages[0] : undefined;
-            result = await exportFromFile(parsed.export, outputPath);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : "Failed to export session";
-            console.error(chalk.red(`Error: ${message}`));
-            process.exit(1);
-        }
-        console.log(`Exported to: ${result}`);
-        process.exit(0);
-    }
-    let appMode = resolveAppMode(parsed, process.stdin.isTTY, process.stdout.isTTY);
-    const shouldTakeOverStdout = appMode !== "interactive" && !isPlainRuntimeMetadataCommand(parsed);
-    if (shouldTakeOverStdout) {
-        takeOverStdout();
-    }
-    if (parsed.mode === "rpc" && parsed.fileArgs.length > 0) {
-        console.error(chalk.red("Error: @file arguments are not supported in RPC mode"));
-        process.exit(1);
-    }
-    validateForkFlags(parsed);
-    validateSessionIdFlags(parsed);
-    // Run migrations (pass cwd for project-local migrations)
-    const { migratedAuthProviders: migratedProviders, deprecationWarnings } = runMigrations(cwd);
-    time("runMigrations");
-    const startupSettingsManager = SettingsManager.create(cwd, agentDir);
-    reportDiagnostics(collectSettingsDiagnostics(startupSettingsManager, "startup session lookup"));
-    // Experimental first-time setup: theme choice and analytics opt-in.
-    // Runs before any runtime services are created so the chosen settings apply everywhere.
-    if (appMode === "interactive" && !parsed.help && parsed.listModels === undefined && shouldRunFirstTimeSetup()) {
-        await showFirstTimeSetup(startupSettingsManager);
-        time("firstTimeSetup");
-    }
-    if (appMode === "interactive" && parsed.useTheme !== undefined) {
-        startupSettingsManager.applyOverrides({ theme: parsed.useTheme });
-    }
-    // Decide the final runtime cwd before creating cwd-bound runtime services.
-    // --session and --resume may select a session from another project, so project-local
-    // settings, resources, provider registrations, and models must be resolved only after
-    // the target session cwd is known. The startup-cwd settings manager is used only for
-    // sessionDir lookup during session selection.
-    const envSessionDir = process.env[ENV_SESSION_DIR];
-    const sessionDir = (parsed.sessionDir ? normalizePath(parsed.sessionDir) : undefined) ??
-        (envSessionDir ? expandTildePath(envSessionDir) : undefined) ??
-        startupSettingsManager.getSessionDir();
-    let sessionManager = await createSessionManager(parsed, cwd, sessionDir, startupSettingsManager);
-    const missingSessionCwdIssue = getMissingSessionCwdIssue(sessionManager, cwd);
-    if (missingSessionCwdIssue) {
-        if (appMode === "interactive") {
-            const selectedCwd = await promptForMissingSessionCwd(missingSessionCwdIssue, startupSettingsManager);
-            if (!selectedCwd) {
-                process.exit(0);
-            }
-            sessionManager = SessionManager.open(missingSessionCwdIssue.sessionFile, sessionDir, selectedCwd);
-        }
-        else {
-            console.error(chalk.red(new MissingSessionCwdError(missingSessionCwdIssue).message));
-            process.exit(1);
-        }
-    }
-    if (parsed.name !== undefined) {
-        const name = parsed.name.trim();
-        if (!name) {
-            console.error(chalk.red("Error: --name requires a non-empty value"));
-            process.exit(1);
-        }
-        sessionManager.appendSessionInfo(name);
-    }
-    time("createSessionManager");
-    const trustStore = new ProjectTrustStore(agentDir);
-    const sessionCwd = sessionManager.getCwd();
-    const autoTrustOnReloadCwd = parsed.projectTrustOverride === undefined && !hasTrustRequiringProjectResources(sessionCwd)
-        ? sessionCwd
-        : undefined;
-    const trustPromptMode = parsed.help || parsed.listModels !== undefined ? "print" : appMode;
-    const projectTrustByCwd = new Map();
-    const resolvedExtensionPaths = resolveCliPaths(cwd, parsed.extensions);
-    const resolvedSkillPaths = resolveCliPaths(cwd, parsed.skills);
-    const resolvedPromptTemplatePaths = resolveCliPaths(cwd, parsed.promptTemplates);
-    const resolvedThemePaths = resolveCliPaths(cwd, parsed.themes);
-    // Bundled Selesai resources ship in dist and load through the same hooks as CLI paths.
-    const bundledExtensionPaths = [getBundledExtensionsDir()];
-    const bundledThemePaths = [getBundledThemesDir()];
-    const bundledSkillPaths = [getBundledSkillsDir()];
-    const createRuntime = async ({ cwd, agentDir, sessionManager, sessionStartEvent, projectTrustContext, }) => {
-        const isInitialRuntime = sessionStartEvent === undefined;
-        const projectTrustDiagnostics = [];
-        const cachedProjectTrust = projectTrustByCwd.get(cwd);
-        const hasTrustRequiringResources = hasTrustRequiringProjectResources(cwd);
-        const shouldResolveProjectTrust = parsed.projectTrustOverride === undefined && cachedProjectTrust === undefined && hasTrustRequiringResources;
-        const projectTrusted = shouldResolveProjectTrust
-            ? false
-            : (cachedProjectTrust ??
-                parsed.projectTrustOverride ??
-                (!hasTrustRequiringResources || trustStore.get(cwd) === true));
-        const runtimeSettingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted });
-        const services = await createAgentSessionServices({
-            cwd,
-            agentDir,
-            settingsManager: runtimeSettingsManager,
-            extensionFlagValues: parsed.unknownFlags,
-            resourceLoaderReloadOptions: shouldResolveProjectTrust
-                ? {
-                    resolveProjectTrust: async ({ extensionsResult }) => {
-                        const trusted = await resolveProjectTrusted({
-                            cwd,
-                            trustStore,
-                            trustOverride: parsed.projectTrustOverride,
-                            defaultProjectTrust: startupSettingsManager.getDefaultProjectTrust(),
-                            extensionsResult,
-                            projectTrustContext: projectTrustContext ??
-                                createProjectTrustContext({
-                                    cwd,
-                                    mode: isInitialRuntime ? trustPromptMode : appMode,
-                                    settingsManager: startupSettingsManager,
-                                    hasUI: isInitialRuntime && trustPromptMode === "interactive",
-                                }),
-                            onExtensionError: (message) => projectTrustDiagnostics.push({ type: "warning", message }),
-                        });
-                        projectTrustByCwd.set(cwd, trusted);
-                        return trusted;
-                    },
-                }
-                : undefined,
-            resourceLoaderOptions: {
-                additionalExtensionPaths: [...bundledExtensionPaths, ...(resolvedExtensionPaths ?? [])],
-                additionalSkillPaths: [...bundledSkillPaths, ...(resolvedSkillPaths ?? [])],
-                additionalAgentPaths: [],
-                additionalPromptTemplatePaths: resolvedPromptTemplatePaths,
-                additionalThemePaths: [...bundledThemePaths, ...(resolvedThemePaths ?? [])],
-                noExtensions: parsed.noExtensions,
-                noSkills: parsed.noSkills,
-                noPromptTemplates: parsed.noPromptTemplates,
-                noThemes: parsed.noThemes,
-                noContextFiles: parsed.noContextFiles,
-                systemPrompt: parsed.systemPrompt,
-                appendSystemPrompt: parsed.appendSystemPrompt,
-                extensionFactories,
-            },
-        });
-        const { settingsManager, modelRuntime, resourceLoader } = services;
-        const diagnostics = [
-            ...projectTrustDiagnostics,
-            ...services.diagnostics,
-            ...collectSettingsDiagnostics(settingsManager, "runtime creation"),
-            ...resourceLoader.getExtensions().errors.map(({ path, error }) => ({
-                type: "error",
-                message: `Failed to load extension "${path}": ${error}`,
-            })),
-            ...resourceLoader.getExtensionDiagnostics().map((d) => ({
-                type: (d.type === "error" ? "error" : "warning"),
-                message: d.message,
-            })),
-        ];
-        const modelPatterns = parsed.models ?? settingsManager.getEnabledModels();
-        const scopedModels = modelPatterns && modelPatterns.length > 0 ? await resolveModelScope(modelPatterns, modelRuntime) : [];
-        const { options: sessionOptions, cliThinkingFromModel, diagnostics: sessionOptionDiagnostics, } = buildSessionOptions(parsed, scopedModels, sessionManager.buildSessionContext().messages.length > 0, modelRuntime, settingsManager);
-        diagnostics.push(...sessionOptionDiagnostics);
-        if (parsed.apiKey) {
-            if (!sessionOptions.model) {
-                diagnostics.push({
-                    type: "error",
-                    message: "--api-key requires a model to be specified via --model, --provider/--model, or --models",
-                });
-            }
-            else {
-                await modelRuntime.setRuntimeApiKey(sessionOptions.model.provider, parsed.apiKey, { allowNetwork: false });
-                await services.modelRuntime.getAvailable();
-            }
-        }
-        const created = await createAgentSessionFromServices({
-            services,
-            sessionManager,
-            sessionStartEvent,
-            model: sessionOptions.model,
-            thinkingLevel: sessionOptions.thinkingLevel,
-            scopedModels: sessionOptions.scopedModels,
-            tools: sessionOptions.tools,
-            excludeTools: sessionOptions.excludeTools,
-            noTools: sessionOptions.noTools,
-            customTools: sessionOptions.customTools,
-        });
-        const cliThinkingOverride = parsed.thinking !== undefined || cliThinkingFromModel;
-        if (created.session.model && cliThinkingOverride) {
-            created.session.setThinkingLevel(created.session.thinkingLevel);
-        }
-        return {
-            ...created,
-            services,
-            diagnostics,
-        };
-    };
-    time("createRuntime");
-    const runtime = await createAgentSessionRuntime(createRuntime, {
-        cwd: sessionManager.getCwd(),
-        agentDir,
-        sessionManager,
-    });
-    time("createAgentSessionRuntime");
-    const { services, session, modelFallbackMessage } = runtime;
-    const { settingsManager, modelRuntime, resourceLoader } = services;
-    setCapabilityOverrides(settingsManager.getTerminalCapabilityOverrides());
-    applyHttpProxySettings(settingsManager.getGlobalSettings().httpProxy);
-    configureHttpDispatcher(settingsManager.getHttpIdleTimeoutMs());
-    if (parsed.help) {
-        const extensionFlags = resourceLoader
-            .getExtensions()
-            .extensions.flatMap((extension) => Array.from(extension.flags.values()));
-        printHelp(extensionFlags);
-        process.exit(0);
-    }
-    if (parsed.listModels !== undefined) {
-        const searchPattern = typeof parsed.listModels === "string" ? parsed.listModels : undefined;
-        await listModels(modelRuntime, searchPattern);
-        process.exit(0);
-    }
-    // Read piped stdin content (if any) - skip for RPC mode which uses stdin for JSON-RPC
-    let stdinContent;
-    if (appMode !== "rpc") {
-        stdinContent = await readPipedStdin();
-        if (stdinContent !== undefined && appMode === "interactive") {
-            appMode = "print";
-        }
-    }
-    time("readPipedStdin");
-    const { initialMessage, initialImages } = await prepareInitialMessage(parsed, settingsManager.getImageAutoResize(), stdinContent);
-    time("prepareInitialMessage");
-    initTheme(settingsManager.getTheme(), appMode === "interactive");
-    time("initTheme");
-    // Show deprecation warnings in interactive mode
-    if (appMode === "interactive" && deprecationWarnings.length > 0) {
-        await showDeprecationWarnings(deprecationWarnings);
-    }
-    time("resolveModelScope");
-    reportDiagnostics(runtime.diagnostics);
-    if (runtime.diagnostics.some((diagnostic) => diagnostic.type === "error")) {
-        if (runtime.diagnostics.some((diagnostic) => diagnostic.message.includes("Failed to load extension"))) {
-            console.error(chalk.yellow(EXTENSION_LOAD_FAILURE_HINT));
-        }
-        process.exit(1);
-    }
-    time("createAgentSession");
-    if (appMode !== "interactive" && !session.model) {
-        console.error(chalk.red(formatNoModelsAvailableMessage()));
-        process.exit(1);
-    }
-    const startupBenchmark = isTruthyEnvFlag(process.env.PI_STARTUP_BENCHMARK);
-    if (startupBenchmark && appMode !== "interactive") {
-        console.error(chalk.red("Error: PI_STARTUP_BENCHMARK only supports interactive mode"));
-        process.exit(1);
-    }
-    // RPC refreshes catalogs here in the background; interactive mode starts its refresh after TUI initialization.
-    if (!offlineMode && appMode === "rpc") {
-        void modelRuntime.refresh().catch(() => { });
-    }
-    if (appMode === "rpc") {
-        printTimings();
-        await runRpcMode(runtime);
-    }
-    else if (appMode === "interactive") {
-        const interactiveMode = new InteractiveMode(runtime, {
-            migratedProviders,
-            modelFallbackMessage,
-            autoTrustOnReloadCwd,
-            initialMessage,
-            initialImages,
-            initialMessages: parsed.messages,
-            verbose: parsed.verbose,
-            tuiMode: parsed.tuiMode,
-            initialThemeSetting: parsed.useTheme,
-        });
-        if (startupBenchmark) {
-            await interactiveMode.init();
-            time("interactiveMode.init");
-            // Give the TUI's stdin handler a brief chance to consume terminal query replies
-            // (Kitty keyboard protocol, device attributes, cell size) before restoring the terminal.
-            await new Promise((resolve) => setTimeout(resolve, 150));
-            interactiveMode.stop();
-            stopThemeWatcher();
-            printTimings();
-            if (process.stdout.writableLength > 0) {
-                await new Promise((resolve) => process.stdout.once("drain", resolve));
-            }
-            if (process.stderr.writableLength > 0) {
-                await new Promise((resolve) => process.stderr.once("drain", resolve));
-            }
-            return;
-        }
-        printTimings();
-        await interactiveMode.run();
-    }
-    else {
-        printTimings();
-        const exitCode = await runPrintMode(runtime, {
-            mode: toPrintOutputMode(appMode),
-            messages: parsed.messages,
-            initialMessage,
-            initialImages,
-        });
-        stopThemeWatcher();
-        restoreStdout();
-        if (exitCode !== 0) {
-            process.exitCode = exitCode;
-        }
-        return;
-    }
-}