@sammorrowdrums/mcpi 0.70.8 → 0.85.0-bootstrap.0

package/dist/main.js

@@ -4,35 +4,44 @@
  * This file handles CLI argument parsing and translates them into
  * createAgentSession() options. The SDK does the heavy lifting.
  */
-import { resolve } from "node:path";
 import { createInterface } from "node:readline";
-import { ProcessTerminal, setKeybindings, TUI } from "@mariozechner/pi-tui";
-import { modelsAreEqual, supportsXhigh } from "@sammorrowdrums/mcpi-ai";
+import { modelsAreEqual } from "@sammorrowdrums/mcpi-ai";
 import chalk from "chalk";
 import { parseArgs, printHelp } from "./cli/args.js";
+import { checkProviderAuth, createAuthCheckModelRuntime, getProviderCredential, } from "./cli/auth-check.js";
+import { AuthCommandError, getAuthCommandName, getAuthCommandUsage, isAuthCommandHelp, parseAuthCommand, printAuthCommandHelp, validateAuthCommandArgs, } from "./cli/auth-command.js";
+import { resolveCredentialForPrint } 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 { getAgentDir, VERSION } from "./config.js";
+import { shouldRunFirstTimeSetup, showFirstTimeSetup, showStartupSelector } from "./cli/startup-ui.js";
+import { APP_NAME, ENV_SESSION_DIR, expandTildePath, getAgentDir, getCacheDir, 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 { AuthStorage } from "./core/auth-storage.js";
+import { AuthStorage, ReadOnlyAuthStorage } from "./core/auth-storage.js";
 import { exportFromFile } from "./core/export-html/index.js";
-import { KeybindingsManager } from "./core/keybindings.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 { SessionManager } from "./core/session-manager.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 "./extensions/index.js";
 import { runMigrations, showDeprecationWarnings } from "./migrations.js";
 import { InteractiveMode, runPrintMode, runRpcMode } from "./modes/index.js";
-import { ExtensionSelectorComponent } from "./modes/interactive/components/extension-selector.js";
 import { initTheme, stopThemeWatcher } from "./modes/interactive/theme/theme.js";
 import { handleConfigCommand, handlePackageCommand } from "./package-manager-cli.js";
-import { isLocalPath } from "./utils/paths.js";
+import { assertNoLegacyPaths } from "./path-migration.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 "${APP_NAME} -ne".`;
 /**
  * Read all content from piped stdin.
  * Returns undefined if stdin is a TTY (interactive terminal).
@@ -72,14 +81,14 @@ function isTruthyEnvFlag(value) {
         return false;
     return value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes";
 }
-function resolveAppMode(parsed, stdinIsTTY) {
+function resolveAppMode(parsed, stdinIsTTY, stdoutIsTTY) {
     if (parsed.mode === "rpc") {
         return "rpc";
     }
     if (parsed.mode === "json") {
         return "json";
     }
-    if (parsed.print || !stdinIsTTY) {
+    if (parsed.print || !stdinIsTTY || !stdoutIsTTY) {
         return "print";
     }
     return "interactive";
@@ -87,6 +96,81 @@ function resolveAppMode(parsed, stdinIsTTY) {
 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 runAuthCommand(args) {
+    if (isAuthCommandHelp(args)) {
+        printAuthCommandHelp();
+        return true;
+    }
+    let command;
+    try {
+        command = parseAuthCommand(args);
+    }
+    catch (error) {
+        const message = error instanceof AuthCommandError ? 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.unknownFlags.size > 0) {
+        const option = parsed.unknownFlags.keys().next().value;
+        console.error(chalk.red(`Unknown option --${option} for "${getAuthCommandName(command.kind)}".`));
+        console.error(chalk.dim(`Use "${APP_NAME} --help" or "${getAuthCommandUsage(command.kind)}".`));
+        process.exitCode = 1;
+        return true;
+    }
+    try {
+        if (parsed.diagnostics.length > 0) {
+            throw new AuthCommandError(parsed.diagnostics.map((diagnostic) => diagnostic.message).join("\n"));
+        }
+        if (command.kind !== "check") {
+            const signal = AbortSignal.timeout(15_000);
+            const modelRuntime = await ModelRuntime.create({ allowModelNetwork: false, signal });
+            const credential = await resolveCredentialForPrint(parsed, modelRuntime, command.kind, command.minExpiryMs, signal);
+            process.stdout.write(`${credential}\n`);
+            return true;
+        }
+        const requestedAuth = validateAuthCommandArgs(parsed, command.kind);
+        let result;
+        let credential;
+        try {
+            const credentials = command.noRefresh ? new ReadOnlyAuthStorage() : AuthStorage.create();
+            const modelRuntime = await createAuthCheckModelRuntime(credentials);
+            result = await checkProviderAuth(parsed, modelRuntime, { refresh: !command.noRefresh });
+            if (command.credentials && result.status === "ready") {
+                credential = await getProviderCredential(result.provider, modelRuntime, credentials, {
+                    refresh: !command.noRefresh,
+                });
+                if (!credential) {
+                    result = { status: "not_ready", provider: result.provider, reason: "credential_not_available" };
+                }
+            }
+        }
+        catch {
+            result = {
+                status: "invalid",
+                provider: requestedAuth.provider ?? requestedAuth.model,
+                reason: "invalid_state",
+            };
+        }
+        const output = command.json
+            ? JSON.stringify({ ...result, ...(credential ? { credentials: credential } : {}) })
+            : (credential ?? result.status);
+        process.stdout.write(`${output}\n`);
+        process.exitCode = result.status === "ready" ? 0 : result.status === "not_ready" ? 1 : 2;
+    }
+    catch (error) {
+        const message = error instanceof AuthCommandError ? error.message : "Failed to resolve credential";
+        console.error(chalk.red(`Error: ${message}`));
+        process.exitCode = command.kind === "check" ? 2 : 1;
+    }
+    return true;
+}
 async function prepareInitialMessage(parsed, autoResizeImages, stdinContent) {
     if (parsed.fileArgs.length === 0) {
         return buildInitialMessage({ parsed, stdinContent });
@@ -103,23 +187,27 @@ async function prepareInitialMessage(parsed, autoResizeImages, 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, use as-is
+    // 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: sessionArg };
+        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 localMatches = localSessions.filter((s) => s.id.startsWith(sessionArg));
-    if (localMatches.length >= 1) {
-        return { type: "local", path: localMatches[0].path };
+    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();
-    const globalMatches = allSessions.filter((s) => s.id.startsWith(sessionArg));
-    if (globalMatches.length >= 1) {
-        const match = globalMatches[0];
-        return { type: "global", path: match.path, cwd: match.cwd };
+    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 };
@@ -151,9 +239,40 @@ function validateForkFlags(parsed) {
         process.exit(1);
     }
 }
-function forkSessionOrExit(sourcePath, cwd, sessionDir) {
+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 {
-        return SessionManager.forkFrom(sourcePath, cwd, sessionDir);
+        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);
@@ -162,16 +281,23 @@ function forkSessionOrExit(sourcePath, cwd, sessionDir) {
     }
 }
 async function createSessionManager(parsed, cwd, sessionDir, settingsManager) {
-    if (parsed.noSession) {
-        return SessionManager.inMemory();
+    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);
+                return forkSessionOrExit(resolved.path, cwd, sessionDir, parsed.sessionId);
             case "not_found":
                 console.error(chalk.red(`No session found matching '${resolved.arg}'`));
                 process.exit(1);
@@ -182,7 +308,7 @@ async function createSessionManager(parsed, cwd, sessionDir, settingsManager) {
         switch (resolved.type) {
             case "path":
             case "local":
-                return SessionManager.open(resolved.path, sessionDir);
+                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?");
@@ -198,9 +324,8 @@ async function createSessionManager(parsed, cwd, sessionDir, settingsManager) {
         }
     }
     if (parsed.resume) {
-        initTheme(settingsManager.getTheme(), true);
         try {
-            const selectedPath = await selectSession((onProgress) => SessionManager.list(cwd, sessionDir, onProgress), SessionManager.listAll);
+            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);
@@ -214,9 +339,16 @@ async function createSessionManager(parsed, cwd, sessionDir, settingsManager) {
     if (parsed.continue) {
         return SessionManager.continueRecent(cwd, sessionDir);
     }
-    return SessionManager.create(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, modelRegistry, settingsManager) {
+function buildSessionOptions(parsed, scopedModels, hasExistingSession, modelRuntime, settingsManager) {
     const options = {};
     const diagnostics = [];
     let cliThinkingFromModel = false;
@@ -227,7 +359,8 @@ function buildSessionOptions(parsed, scopedModels, hasExistingSession, modelRegi
         const resolved = resolveCliModel({
             cliProvider: parsed.provider,
             cliModel: parsed.model,
-            modelRegistry,
+            cliThinking: parsed.thinking,
+            modelRuntime,
         });
         if (resolved.warning) {
             diagnostics.push({ type: "warning", message: resolved.warning });
@@ -249,7 +382,7 @@ function buildSessionOptions(parsed, scopedModels, hasExistingSession, modelRegi
         // 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 ? modelRegistry.find(savedProvider, savedModelId) : undefined;
+        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;
@@ -279,7 +412,7 @@ function buildSessionOptions(parsed, scopedModels, hasExistingSession, modelRegi
             thinkingLevel: sm.thinkingLevel,
         }));
     }
-    // API key from CLI - set in authStorage
+    // API key from CLI - set as a non-persistent runtime override
     // (handled by caller before createAgentSession)
     // Tools
     if (parsed.noTools) {
@@ -291,43 +424,53 @@ function buildSessionOptions(parsed, scopedModels, hasExistingSession, modelRegi
     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) ? resolve(cwd, value) : value));
+    return paths?.map((value) => (isLocalPath(value) ? resolvePath(value, cwd) : value));
 }
 async function promptForMissingSessionCwd(issue, settingsManager) {
-    initTheme(settingsManager.getTheme());
-    setKeybindings(KeybindingsManager.create());
-    return new Promise((resolve) => {
-        const ui = new TUI(new ProcessTerminal(), settingsManager.getShowHardwareCursor());
-        ui.setClearOnShrink(settingsManager.getClearOnShrink());
-        let settled = false;
-        const finish = (result) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            ui.stop();
-            resolve(result);
-        };
-        const selector = new ExtensionSelectorComponent(formatMissingSessionCwdPrompt(issue), ["Continue", "Cancel"], (option) => finish(option === "Continue" ? issue.fallbackCwd : undefined), () => finish(undefined), { tui: ui });
-        ui.addChild(selector);
-        ui.setFocus(selector);
-        ui.start();
-    });
+    return showStartupSelector(settingsManager, formatMissingSessionCwdPrompt(issue), [
+        { label: "Continue", value: issue.fallbackCwd },
+        { label: "Cancel", value: undefined },
+    ]);
 }
 export async function main(args, options) {
     resetTimings();
-    const offlineMode = args.includes("--offline") || isTruthyEnvFlag(process.env.PI_OFFLINE);
+    const extensionFactories = [...builtInExtensions, ...(options?.extensionFactories ?? [])];
+    const cwd = process.cwd();
+    assertNoLegacyPaths(cwd);
+    const offlineMode = args.includes("--offline") || isTruthyEnvFlag(process.env.MCPI_OFFLINE);
     if (offlineMode) {
-        process.env.PI_OFFLINE = "1";
-        process.env.PI_SKIP_VERSION_CHECK = "1";
+        process.env.MCPI_OFFLINE = "1";
+        process.env.MCPI_SKIP_VERSION_CHECK = "1";
     }
-    if (await handlePackageCommand(args)) {
+    if (await runAuthCommand(args)) {
+        return;
+    }
+    if (process.platform === "win32") {
+        cleanupWindowsSelfUpdateQuarantine(getPackageDir());
+    }
+    const agentDir = getAgentDir();
+    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 `mcpi update` drain naturally instead.
+            // https://github.com/nodejs/node/issues/56645
+            return;
+        }
+        process.exit(exitCode);
         return;
     }
-    if (await handleConfigCommand(args)) {
+    if (await handleConfigCommand(args, { extensionFactories })) {
         return;
     }
     const parsed = parseArgs(args);
@@ -341,11 +484,6 @@ export async function main(args, options) {
         }
     }
     time("parseArgs");
-    let appMode = resolveAppMode(parsed, process.stdin.isTTY);
-    const shouldTakeOverStdout = appMode !== "interactive";
-    if (shouldTakeOverStdout) {
-        takeOverStdout();
-    }
     if (parsed.version) {
         console.log(VERSION);
         process.exit(0);
@@ -364,24 +502,40 @@ export async function main(args, options) {
         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(process.cwd());
+    const { migratedAuthProviders: migratedProviders, deprecationWarnings } = runMigrations(cwd);
     time("runMigrations");
-    const cwd = process.cwd();
-    const agentDir = getAgentDir();
     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 sessionDir = parsed.sessionDir ?? startupSettingsManager.getSessionDir();
+    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) {
@@ -397,18 +551,68 @@ export async function main(args, options) {
             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);
-    const authStorage = AuthStorage.create();
-    const createRuntime = async ({ cwd, agentDir, sessionManager, sessionStartEvent, }) => {
+    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,
-            authStorage,
+            cacheDir: getCacheDir(),
+            settingsManager: runtimeSettingsManager,
+            modelRuntimeSignal: AbortSignal.timeout(15_000),
             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: resolvedExtensionPaths,
                 additionalSkillPaths: resolvedSkillPaths,
@@ -421,11 +625,12 @@ export async function main(args, options) {
                 noContextFiles: parsed.noContextFiles,
                 systemPrompt: parsed.systemPrompt,
                 appendSystemPrompt: parsed.appendSystemPrompt,
-                extensionFactories: options?.extensionFactories,
+                extensionFactories,
             },
         });
-        const { settingsManager, modelRegistry, resourceLoader } = services;
+        const { settingsManager, modelRuntime, resourceLoader } = services;
         const diagnostics = [
+            ...projectTrustDiagnostics,
             ...services.diagnostics,
             ...collectSettingsDiagnostics(settingsManager, "runtime creation"),
             ...resourceLoader.getExtensions().errors.map(({ path, error }) => ({
@@ -434,8 +639,10 @@ export async function main(args, options) {
             })),
         ];
         const modelPatterns = parsed.models ?? settingsManager.getEnabledModels();
-        const scopedModels = modelPatterns && modelPatterns.length > 0 ? await resolveModelScope(modelPatterns, modelRegistry) : [];
-        const { options: sessionOptions, cliThinkingFromModel, diagnostics: sessionOptionDiagnostics, } = buildSessionOptions(parsed, scopedModels, sessionManager.buildSessionContext().messages.length > 0, modelRegistry, settingsManager);
+        const scopedModels = modelPatterns && modelPatterns.length > 0
+            ? await resolveModelScope(modelPatterns, modelRuntime, { signal: AbortSignal.timeout(15_000) })
+            : [];
+        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) {
@@ -445,7 +652,7 @@ export async function main(args, options) {
                 });
             }
             else {
-                authStorage.setRuntimeApiKey(sessionOptions.model.provider, parsed.apiKey);
+                await modelRuntime.setRuntimeApiKey(sessionOptions.model.provider, parsed.apiKey);
             }
         }
         const created = await createAgentSessionFromServices({
@@ -456,21 +663,13 @@ export async function main(args, options) {
             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) {
-            let effectiveThinking = created.session.thinkingLevel;
-            if (!created.session.model.reasoning) {
-                effectiveThinking = "off";
-            }
-            else if (effectiveThinking === "xhigh" && !supportsXhigh(created.session.model)) {
-                effectiveThinking = "high";
-            }
-            if (effectiveThinking !== created.session.thinkingLevel) {
-                created.session.setThinkingLevel(effectiveThinking);
-            }
+            created.session.setThinkingLevel(created.session.thinkingLevel);
         }
         return {
             ...created,
@@ -484,8 +683,11 @@ export async function main(args, options) {
         agentDir,
         sessionManager,
     });
+    time("createAgentSessionRuntime");
     const { services, session, modelFallbackMessage } = runtime;
-    const { settingsManager, modelRegistry, resourceLoader } = services;
+    const { settingsManager, modelRuntime, resourceLoader } = services;
+    applyHttpProxySettings(settingsManager.getGlobalSettings().httpProxy);
+    configureHttpDispatcher(settingsManager.getHttpIdleTimeoutMs());
     if (parsed.help) {
         const extensionFlags = resourceLoader
             .getExtensions()
@@ -495,7 +697,7 @@ export async function main(args, options) {
     }
     if (parsed.listModels !== undefined) {
         const searchPattern = typeof parsed.listModels === "string" ? parsed.listModels : undefined;
-        await listModels(modelRegistry, searchPattern);
+        await listModels(modelRuntime, searchPattern, AbortSignal.timeout(15_000));
         process.exit(0);
     }
     // Read piped stdin content (if any) - skip for RPC mode which uses stdin for JSON-RPC
@@ -515,10 +717,12 @@ export async function main(args, options) {
     if (appMode === "interactive" && deprecationWarnings.length > 0) {
         await showDeprecationWarnings(deprecationWarnings);
     }
-    const scopedModels = [...session.scopedModels];
     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");
@@ -526,39 +730,45 @@ export async function main(args, options) {
         console.error(chalk.red(formatNoModelsAvailableMessage()));
         process.exit(1);
     }
-    const startupBenchmark = isTruthyEnvFlag(process.env.PI_STARTUP_BENCHMARK);
+    const startupBenchmark = isTruthyEnvFlag(process.env.MCPI_STARTUP_BENCHMARK);
     if (startupBenchmark && appMode !== "interactive") {
-        console.error(chalk.red("Error: PI_STARTUP_BENCHMARK only supports interactive mode"));
+        console.error(chalk.red("Error: MCPI_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") {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 15_000);
+        void modelRuntime
+            .refresh({ signal: controller.signal })
+            .catch(() => { })
+            .finally(() => clearTimeout(timeout));
+    }
     if (appMode === "rpc") {
         printTimings();
         await runRpcMode(runtime);
     }
     else if (appMode === "interactive") {
-        if (scopedModels.length > 0 && (parsed.verbose || !settingsManager.getQuietStartup())) {
-            const modelList = scopedModels
-                .map((sm) => {
-                const thinkingStr = sm.thinkingLevel ? `:${sm.thinkingLevel}` : "";
-                return `${sm.model.id}${thinkingStr}`;
-            })
-                .join(", ");
-            console.log(chalk.dim(`Model scope: ${modelList} ${chalk.gray("(Ctrl+P to cycle)")}`));
-        }
         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");
-            printTimings();
+            // 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));
             }