@phi-code-admin/phi-code 0.74.2 → 0.75.0

package/dist/main.js

@@ -4,30 +4,35 @@
  * This file handles CLI argument parsing and translates them into
  * createAgentSession() options. The SDK does the heavy lifting.
  */
-import { modelsAreEqual, supportsXhigh } from "phi-code-ai";
+import { resolve } from "node:path";
+import { createInterface } from "node:readline";
 import chalk from "chalk";
-import { createInterface } from "readline";
+import { modelsAreEqual } from "phi-code-ai";
+import { ProcessTerminal, setKeybindings, TUI } from "phi-code-tui";
 import { parseArgs, printHelp } from "./cli/args.js";
-import { selectConfig } from "./cli/config-selector.js";
 import { processFileArguments } from "./cli/file-processor.js";
+import { buildInitialMessage } from "./cli/initial-message.js";
 import { listModels } from "./cli/list-models.js";
 import { selectSession } from "./cli/session-picker.js";
-import { APP_NAME, getAgentDir, getModelsPath, VERSION } from "./config.js";
+import { ENV_SESSION_DIR, expandTildePath, getAgentDir, 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 { exportFromFile } from "./core/export-html/index.js";
 import { KeybindingsManager } from "./core/keybindings.js";
-import { ModelRegistry } from "./core/model-registry.js";
 import { resolveCliModel, resolveModelScope } from "./core/model-resolver.js";
-import { DefaultPackageManager } from "./core/package-manager.js";
-import { DefaultResourceLoader } from "./core/resource-loader.js";
-import { createAgentSession } from "./core/sdk.js";
+import { restoreStdout, takeOverStdout } from "./core/output-guard.js";
+import { formatMissingSessionCwdPrompt, getMissingSessionCwdIssue, MissingSessionCwdError, } from "./core/session-cwd.js";
 import { SessionManager } from "./core/session-manager.js";
 import { SettingsManager } from "./core/settings-manager.js";
-import { printTimings, time } from "./core/timings.js";
-import { allTools } from "./core/tools/index.js";
+import { printTimings, resetTimings, time } from "./core/timings.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";
 /**
  * Read all content from piped stdin.
  * Returns undefined if stdin is a TTY (interactive terminal).
@@ -49,13 +54,17 @@ async function readPipedStdin() {
         process.stdin.resume();
     });
 }
-function reportSettingsErrors(settingsManager, context) {
-    const errors = settingsManager.drainErrors();
-    for (const { scope, error } of errors) {
-        console.error(chalk.yellow(`Warning (${context}, ${scope} settings): ${error.message}`));
-        if (error.stack) {
-            console.error(chalk.dim(error.stack));
-        }
+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) {
@@ -63,221 +72,32 @@ function isTruthyEnvFlag(value) {
         return false;
     return value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes";
 }
-function getPackageCommandUsage(command) {
-    switch (command) {
-        case "install":
-            return `${APP_NAME} install <source> [-l]`;
-        case "remove":
-            return `${APP_NAME} remove <source> [-l]`;
-        case "update":
-            return `${APP_NAME} update [source]`;
-        case "list":
-            return `${APP_NAME} list`;
-    }
-}
-function printPackageCommandHelp(command) {
-    switch (command) {
-        case "install":
-            console.log(`${chalk.bold("Usage:")}
-  ${getPackageCommandUsage("install")}
-
-Install a package and add it to settings.
-
-Options:
-  -l, --local    Install project-locally (.pi/settings.json)
-
-Examples:
-  ${APP_NAME} install npm:@foo/bar
-  ${APP_NAME} install git:github.com/user/repo
-  ${APP_NAME} install git:git@github.com:user/repo
-  ${APP_NAME} install https://github.com/user/repo
-  ${APP_NAME} install ssh://git@github.com/user/repo
-  ${APP_NAME} install ./local/path
-`);
-            return;
-        case "remove":
-            console.log(`${chalk.bold("Usage:")}
-  ${getPackageCommandUsage("remove")}
-
-Remove a package and its source from settings.
-
-Options:
-  -l, --local    Remove from project settings (.pi/settings.json)
-
-Example:
-  ${APP_NAME} remove npm:@foo/bar
-`);
-            return;
-        case "update":
-            console.log(`${chalk.bold("Usage:")}
-  ${getPackageCommandUsage("update")}
-
-Update installed packages.
-If <source> is provided, only that package is updated.
-`);
-            return;
-        case "list":
-            console.log(`${chalk.bold("Usage:")}
-  ${getPackageCommandUsage("list")}
-
-List installed packages from user and project settings.
-`);
-            return;
+function resolveAppMode(parsed, stdinIsTTY) {
+    if (parsed.mode === "rpc") {
+        return "rpc";
     }
-}
-function parsePackageCommand(args) {
-    const [command, ...rest] = args;
-    if (command !== "install" && command !== "remove" && command !== "update" && command !== "list") {
-        return undefined;
+    if (parsed.mode === "json") {
+        return "json";
     }
-    let local = false;
-    let help = false;
-    let invalidOption;
-    let source;
-    for (const arg of rest) {
-        if (arg === "-h" || arg === "--help") {
-            help = true;
-            continue;
-        }
-        if (arg === "-l" || arg === "--local") {
-            if (command === "install" || command === "remove") {
-                local = true;
-            }
-            else {
-                invalidOption = invalidOption ?? arg;
-            }
-            continue;
-        }
-        if (arg.startsWith("-")) {
-            invalidOption = invalidOption ?? arg;
-            continue;
-        }
-        if (!source) {
-            source = arg;
-        }
+    if (parsed.print || !stdinIsTTY) {
+        return "print";
     }
-    return { command, source, local, help, invalidOption };
+    return "interactive";
 }
-async function handlePackageCommand(args) {
-    const options = parsePackageCommand(args);
-    if (!options) {
-        return false;
-    }
-    if (options.help) {
-        printPackageCommandHelp(options.command);
-        return true;
-    }
-    if (options.invalidOption) {
-        console.error(chalk.red(`Unknown option ${options.invalidOption} for "${options.command}".`));
-        console.error(chalk.dim(`Use "${APP_NAME} --help" or "${getPackageCommandUsage(options.command)}".`));
-        process.exitCode = 1;
-        return true;
-    }
-    const source = options.source;
-    if ((options.command === "install" || options.command === "remove") && !source) {
-        console.error(chalk.red(`Missing ${options.command} source.`));
-        console.error(chalk.dim(`Usage: ${getPackageCommandUsage(options.command)}`));
-        process.exitCode = 1;
-        return true;
-    }
-    const cwd = process.cwd();
-    const agentDir = getAgentDir();
-    const settingsManager = SettingsManager.create(cwd, agentDir);
-    reportSettingsErrors(settingsManager, "package command");
-    const packageManager = new DefaultPackageManager({ cwd, agentDir, settingsManager });
-    packageManager.setProgressCallback((event) => {
-        if (event.type === "start") {
-            process.stdout.write(chalk.dim(`${event.message}\n`));
-        }
-    });
-    try {
-        switch (options.command) {
-            case "install":
-                await packageManager.install(source, { local: options.local });
-                packageManager.addSourceToSettings(source, { local: options.local });
-                console.log(chalk.green(`Installed ${source}`));
-                return true;
-            case "remove": {
-                await packageManager.remove(source, { local: options.local });
-                const removed = packageManager.removeSourceFromSettings(source, { local: options.local });
-                if (!removed) {
-                    console.error(chalk.red(`No matching package found for ${source}`));
-                    process.exitCode = 1;
-                    return true;
-                }
-                console.log(chalk.green(`Removed ${source}`));
-                return true;
-            }
-            case "list": {
-                const globalSettings = settingsManager.getGlobalSettings();
-                const projectSettings = settingsManager.getProjectSettings();
-                const globalPackages = globalSettings.packages ?? [];
-                const projectPackages = projectSettings.packages ?? [];
-                if (globalPackages.length === 0 && projectPackages.length === 0) {
-                    console.log(chalk.dim("No packages installed."));
-                    return true;
-                }
-                const formatPackage = (pkg, scope) => {
-                    const source = typeof pkg === "string" ? pkg : pkg.source;
-                    const filtered = typeof pkg === "object";
-                    const display = filtered ? `${source} (filtered)` : source;
-                    console.log(`  ${display}`);
-                    const path = packageManager.getInstalledPath(source, scope);
-                    if (path) {
-                        console.log(chalk.dim(`    ${path}`));
-                    }
-                };
-                if (globalPackages.length > 0) {
-                    console.log(chalk.bold("User packages:"));
-                    for (const pkg of globalPackages) {
-                        formatPackage(pkg, "user");
-                    }
-                }
-                if (projectPackages.length > 0) {
-                    if (globalPackages.length > 0)
-                        console.log();
-                    console.log(chalk.bold("Project packages:"));
-                    for (const pkg of projectPackages) {
-                        formatPackage(pkg, "project");
-                    }
-                }
-                return true;
-            }
-            case "update":
-                await packageManager.update(source);
-                if (source) {
-                    console.log(chalk.green(`Updated ${source}`));
-                }
-                else {
-                    console.log(chalk.green("Updated packages"));
-                }
-                return true;
-        }
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown package command error";
-        console.error(chalk.red(`Error: ${message}`));
-        process.exitCode = 1;
-        return true;
-    }
+function toPrintOutputMode(appMode) {
+    return appMode === "json" ? "json" : "text";
 }
-async function prepareInitialMessage(parsed, autoResizeImages) {
+async function prepareInitialMessage(parsed, autoResizeImages, stdinContent) {
     if (parsed.fileArgs.length === 0) {
-        return {};
+        return buildInitialMessage({ parsed, stdinContent });
     }
     const { text, images } = await processFileArguments(parsed.fileArgs, { autoResizeImages });
-    let initialMessage;
-    if (parsed.messages.length > 0) {
-        initialMessage = text + parsed.messages[0];
-        parsed.messages.shift();
-    }
-    else {
-        initialMessage = text;
-    }
-    return {
-        initialMessage,
-        initialImages: images.length > 0 ? images : undefined,
-    };
+    return buildInitialMessage({
+        parsed,
+        fileText: text,
+        fileImages: images,
+        stdinContent,
+    });
 }
 /**
  * Resolve a session argument to a file path.
@@ -317,48 +137,89 @@ async function promptConfirm(message) {
         });
     });
 }
-async function createSessionManager(parsed, cwd) {
+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 forkSessionOrExit(sourcePath, cwd, sessionDir) {
+    try {
+        return SessionManager.forkFrom(sourcePath, cwd, sessionDir);
+    }
+    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) {
         return SessionManager.inMemory();
     }
+    if (parsed.fork) {
+        const resolved = await resolveSessionPath(parsed.fork, cwd, sessionDir);
+        switch (resolved.type) {
+            case "path":
+            case "local":
+            case "global":
+                return forkSessionOrExit(resolved.path, cwd, sessionDir);
+            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, parsed.sessionDir);
+        const resolved = await resolveSessionPath(parsed.session, cwd, sessionDir);
         switch (resolved.type) {
             case "path":
             case "local":
-                return SessionManager.open(resolved.path, parsed.sessionDir);
+                return SessionManager.open(resolved.path, sessionDir);
             case "global": {
-                // Session found in different project - ask user if they want to fork
                 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 SessionManager.forkFrom(resolved.path, cwd, parsed.sessionDir);
+                return forkSessionOrExit(resolved.path, cwd, sessionDir);
             }
             case "not_found":
                 console.error(chalk.red(`No session found matching '${resolved.arg}'`));
                 process.exit(1);
         }
     }
-    if (parsed.continue) {
-        return SessionManager.continueRecent(cwd, parsed.sessionDir);
+    if (parsed.resume) {
+        initTheme(settingsManager.getTheme(), true);
+        try {
+            const selectedPath = await selectSession((onProgress) => SessionManager.list(cwd, sessionDir, onProgress), SessionManager.listAll);
+            if (!selectedPath) {
+                console.log(chalk.dim("No session selected"));
+                process.exit(0);
+            }
+            return SessionManager.open(selectedPath, sessionDir);
+        }
+        finally {
+            stopThemeWatcher();
+        }
     }
-    // --resume is handled separately (needs picker UI)
-    // If --session-dir provided without --continue/--resume, create new session there
-    if (parsed.sessionDir) {
-        return SessionManager.create(cwd, parsed.sessionDir);
+    if (parsed.continue) {
+        return SessionManager.continueRecent(cwd, sessionDir);
     }
-    // Default case (new session) returns undefined, SDK will create one
-    return undefined;
+    return SessionManager.create(cwd, sessionDir);
 }
-function buildSessionOptions(parsed, scopedModels, sessionManager, modelRegistry, settingsManager) {
+function buildSessionOptions(parsed, scopedModels, hasExistingSession, modelRegistry, settingsManager) {
     const options = {};
+    const diagnostics = [];
     let cliThinkingFromModel = false;
-    if (sessionManager) {
-        options.sessionManager = sessionManager;
-    }
     // Model from CLI
     // - supports --provider <name> --model <pattern>
     // - supports --model <provider>/<pattern>
@@ -369,11 +230,10 @@ function buildSessionOptions(parsed, scopedModels, sessionManager, modelRegistry
             modelRegistry,
         });
         if (resolved.warning) {
-            console.warn(chalk.yellow(`Warning: ${resolved.warning}`));
+            diagnostics.push({ type: "warning", message: resolved.warning });
         }
         if (resolved.error) {
-            console.error(chalk.red(resolved.error));
-            process.exit(1);
+            diagnostics.push({ type: "error", message: resolved.error });
         }
         if (resolved.model) {
             options.model = resolved.model;
@@ -385,7 +245,7 @@ function buildSessionOptions(parsed, scopedModels, sessionManager, modelRegistry
             }
         }
     }
-    if (!options.model && scopedModels.length > 0 && !parsed.continue && !parsed.resume) {
+    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();
@@ -423,39 +283,42 @@ function buildSessionOptions(parsed, scopedModels, sessionManager, modelRegistry
     // (handled by caller before createAgentSession)
     // Tools
     if (parsed.noTools) {
-        // --no-tools: start with no built-in tools
-        // --tools can still add specific ones back
-        if (parsed.tools && parsed.tools.length > 0) {
-            options.tools = parsed.tools.map((name) => allTools[name]);
-        }
-        else {
-            options.tools = [];
-        }
+        options.noTools = "all";
     }
-    else if (parsed.tools) {
-        options.tools = parsed.tools.map((name) => allTools[name]);
+    else if (parsed.noBuiltinTools) {
+        options.noTools = "builtin";
     }
-    return { options, cliThinkingFromModel };
-}
-async function handleConfigCommand(args) {
-    if (args[0] !== "config") {
-        return false;
+    if (parsed.tools) {
+        options.tools = [...parsed.tools];
     }
-    const cwd = process.cwd();
-    const agentDir = getAgentDir();
-    const settingsManager = SettingsManager.create(cwd, agentDir);
-    reportSettingsErrors(settingsManager, "config command");
-    const packageManager = new DefaultPackageManager({ cwd, agentDir, settingsManager });
-    const resolvedPaths = await packageManager.resolve();
-    await selectConfig({
-        resolvedPaths,
-        settingsManager,
-        cwd,
-        agentDir,
+    return { options, cliThinkingFromModel, diagnostics };
+}
+function resolveCliPaths(cwd, paths) {
+    return paths?.map((value) => (isLocalPath(value) ? resolve(cwd, value) : 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();
     });
-    process.exit(0);
 }
-export async function main(args) {
+export async function main(args, options) {
+    resetTimings();
     const offlineMode = args.includes("--offline") || isTruthyEnvFlag(process.env.PI_OFFLINE);
     if (offlineMode) {
         process.env.PI_OFFLINE = "1";
@@ -467,79 +330,26 @@ export async function main(args) {
     if (await handleConfigCommand(args)) {
         return;
     }
-    // Run migrations (pass cwd for project-local migrations)
-    const { migratedAuthProviders: migratedProviders, deprecationWarnings } = runMigrations(process.cwd());
-    // First pass: parse args to get --extension paths
-    const firstPass = parseArgs(args);
-    // Early load extensions to discover their CLI flags
-    const cwd = process.cwd();
-    const agentDir = getAgentDir();
-    const settingsManager = SettingsManager.create(cwd, agentDir);
-    reportSettingsErrors(settingsManager, "startup");
-    const authStorage = AuthStorage.create();
-    const modelRegistry = new ModelRegistry(authStorage, getModelsPath());
-    const resourceLoader = new DefaultResourceLoader({
-        cwd,
-        agentDir,
-        settingsManager,
-        additionalExtensionPaths: firstPass.extensions,
-        additionalSkillPaths: firstPass.skills,
-        additionalPromptTemplatePaths: firstPass.promptTemplates,
-        additionalThemePaths: firstPass.themes,
-        noExtensions: firstPass.noExtensions,
-        noSkills: firstPass.noSkills,
-        noPromptTemplates: firstPass.noPromptTemplates,
-        noThemes: firstPass.noThemes,
-        systemPrompt: firstPass.systemPrompt,
-        appendSystemPrompt: firstPass.appendSystemPrompt,
-    });
-    await resourceLoader.reload();
-    time("resourceLoader.reload");
-    const extensionsResult = resourceLoader.getExtensions();
-    for (const { path, error } of extensionsResult.errors) {
-        console.error(chalk.red(`Failed to load extension "${path}": ${error}`));
-    }
-    // Apply pending provider registrations from extensions immediately
-    // so they're available for model resolution before AgentSession is created
-    for (const { name, config } of extensionsResult.runtime.pendingProviderRegistrations) {
-        modelRegistry.registerProvider(name, config);
-    }
-    extensionsResult.runtime.pendingProviderRegistrations = [];
-    const extensionFlags = new Map();
-    for (const ext of extensionsResult.extensions) {
-        for (const [name, flag] of ext.flags) {
-            extensionFlags.set(name, { type: flag.type });
+    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);
         }
     }
-    // Second pass: parse args with extension flags
-    const parsed = parseArgs(args, extensionFlags);
-    // Pass flag values to extensions via runtime
-    for (const [name, value] of parsed.unknownFlags) {
-        extensionsResult.runtime.flagValues.set(name, value);
+    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);
     }
-    if (parsed.help) {
-        printHelp();
-        process.exit(0);
-    }
-    if (parsed.listModels !== undefined) {
-        const searchPattern = typeof parsed.listModels === "string" ? parsed.listModels : undefined;
-        await listModels(modelRegistry, searchPattern);
-        process.exit(0);
-    }
-    // Read piped stdin content (if any) - skip for RPC mode which uses stdin for JSON-RPC
-    if (parsed.mode !== "rpc") {
-        const stdinContent = await readPipedStdin();
-        if (stdinContent !== undefined) {
-            // Force print mode since interactive mode requires a TTY for keyboard input
-            parsed.print = true;
-            // Prepend stdin content to messages
-            parsed.messages.unshift(stdinContent);
-        }
-    }
     if (parsed.export) {
         let result;
         try {
@@ -558,72 +368,168 @@ export async function main(args) {
         console.error(chalk.red("Error: @file arguments are not supported in RPC mode"));
         process.exit(1);
     }
-    const { initialMessage, initialImages } = await prepareInitialMessage(parsed, settingsManager.getImageAutoResize());
-    const isInteractive = !parsed.print && parsed.mode === undefined;
-    const mode = parsed.mode || "text";
-    initTheme(settingsManager.getTheme(), isInteractive);
-    // Show deprecation warnings in interactive mode
-    if (isInteractive && deprecationWarnings.length > 0) {
-        await showDeprecationWarnings(deprecationWarnings);
-    }
-    let scopedModels = [];
-    const modelPatterns = parsed.models ?? settingsManager.getEnabledModels();
-    if (modelPatterns && modelPatterns.length > 0) {
-        scopedModels = await resolveModelScope(modelPatterns, modelRegistry);
-    }
-    // Create session manager based on CLI flags
-    let sessionManager = await createSessionManager(parsed, cwd);
-    // Handle --resume: show session picker
-    if (parsed.resume) {
-        // Initialize keybindings so session picker respects user config
-        KeybindingsManager.create();
-        const selectedPath = await selectSession((onProgress) => SessionManager.list(cwd, parsed.sessionDir, onProgress), SessionManager.listAll);
-        if (!selectedPath) {
-            console.log(chalk.dim("No session selected"));
-            stopThemeWatcher();
-            process.exit(0);
+    validateForkFlags(parsed);
+    // Run migrations (pass cwd for project-local migrations)
+    const { migratedAuthProviders: migratedProviders, deprecationWarnings } = runMigrations(process.cwd());
+    time("runMigrations");
+    const cwd = process.cwd();
+    const agentDir = getAgentDir();
+    const startupSettingsManager = SettingsManager.create(cwd, agentDir);
+    reportDiagnostics(collectSettingsDiagnostics(startupSettingsManager, "startup session lookup"));
+    // 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 ??
+        (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);
         }
-        sessionManager = SessionManager.open(selectedPath);
-    }
-    const { options: sessionOptions, cliThinkingFromModel } = buildSessionOptions(parsed, scopedModels, sessionManager, modelRegistry, settingsManager);
-    sessionOptions.authStorage = authStorage;
-    sessionOptions.modelRegistry = modelRegistry;
-    sessionOptions.resourceLoader = resourceLoader;
-    // Handle CLI --api-key as runtime override (not persisted)
-    if (parsed.apiKey) {
-        if (!sessionOptions.model) {
-            console.error(chalk.red("--api-key requires a model to be specified via --model, --provider/--model, or --models"));
+        else {
+            console.error(chalk.red(new MissingSessionCwdError(missingSessionCwdIssue).message));
             process.exit(1);
         }
-        authStorage.setRuntimeApiKey(sessionOptions.model.provider, parsed.apiKey);
-    }
-    const { session, modelFallbackMessage } = await createAgentSession(sessionOptions);
-    if (!isInteractive && !session.model) {
-        console.error(chalk.red("No models available."));
-        console.error(chalk.yellow("\nSet an API key environment variable:"));
-        console.error("  ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY, etc.");
-        console.error(chalk.yellow(`\nOr create ${getModelsPath()}`));
-        process.exit(1);
     }
-    // Clamp thinking level to model capabilities for CLI-provided thinking levels.
-    // This covers both --thinking <level> and --model <pattern>:<thinking>.
-    const cliThinkingOverride = parsed.thinking !== undefined || cliThinkingFromModel;
-    if (session.model && cliThinkingOverride) {
-        let effectiveThinking = session.thinkingLevel;
-        if (!session.model.reasoning) {
-            effectiveThinking = "off";
+    time("createSessionManager");
+    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 services = await createAgentSessionServices({
+            cwd,
+            agentDir,
+            authStorage,
+            extensionFlagValues: parsed.unknownFlags,
+            resourceLoaderOptions: {
+                additionalExtensionPaths: resolvedExtensionPaths,
+                additionalSkillPaths: resolvedSkillPaths,
+                additionalPromptTemplatePaths: resolvedPromptTemplatePaths,
+                additionalThemePaths: resolvedThemePaths,
+                noExtensions: parsed.noExtensions,
+                noSkills: parsed.noSkills,
+                noPromptTemplates: parsed.noPromptTemplates,
+                noThemes: parsed.noThemes,
+                noContextFiles: parsed.noContextFiles,
+                systemPrompt: parsed.systemPrompt,
+                appendSystemPrompt: parsed.appendSystemPrompt,
+                extensionFactories: options?.extensionFactories,
+            },
+        });
+        const { settingsManager, modelRegistry, resourceLoader } = services;
+        const diagnostics = [
+            ...services.diagnostics,
+            ...collectSettingsDiagnostics(settingsManager, "runtime creation"),
+            ...resourceLoader.getExtensions().errors.map(({ path, error }) => ({
+                type: "error",
+                message: `Failed to load extension "${path}": ${error}`,
+            })),
+        ];
+        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);
+        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 {
+                authStorage.setRuntimeApiKey(sessionOptions.model.provider, parsed.apiKey);
+            }
         }
-        else if (effectiveThinking === "xhigh" && !supportsXhigh(session.model)) {
-            effectiveThinking = "high";
+        const created = await createAgentSessionFromServices({
+            services,
+            sessionManager,
+            sessionStartEvent,
+            model: sessionOptions.model,
+            thinkingLevel: sessionOptions.thinkingLevel,
+            scopedModels: sessionOptions.scopedModels,
+            tools: sessionOptions.tools,
+            noTools: sessionOptions.noTools,
+            customTools: sessionOptions.customTools,
+        });
+        const cliThinkingOverride = parsed.thinking !== undefined || cliThinkingFromModel;
+        if (created.session.model && cliThinkingOverride) {
+            created.session.setThinkingLevel(created.session.thinkingLevel);
         }
-        if (effectiveThinking !== session.thinkingLevel) {
-            session.setThinkingLevel(effectiveThinking);
+        return {
+            ...created,
+            services,
+            diagnostics,
+        };
+    };
+    time("createRuntime");
+    const runtime = await createAgentSessionRuntime(createRuntime, {
+        cwd: sessionManager.getCwd(),
+        agentDir,
+        sessionManager,
+    });
+    const { services, session, modelFallbackMessage } = runtime;
+    const { settingsManager, modelRegistry, resourceLoader } = services;
+    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(modelRegistry, 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";
         }
     }
-    if (mode === "rpc") {
-        await runRpcMode(session);
+    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);
+    }
+    const scopedModels = [...session.scopedModels];
+    time("resolveModelScope");
+    reportDiagnostics(runtime.diagnostics);
+    if (runtime.diagnostics.some((diagnostic) => diagnostic.type === "error")) {
+        process.exit(1);
+    }
+    time("createAgentSession");
+    if (appMode !== "interactive" && !session.model) {
+        console.error(chalk.red(formatNoModelsAvailableMessage()));
+        process.exit(1);
     }
-    else if (isInteractive) {
+    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);
+    }
+    if (appMode === "rpc") {
+        printTimings();
+        await runRpcMode(runtime);
+    }
+    else if (appMode === "interactive") {
         if (scopedModels.length > 0 && (parsed.verbose || !settingsManager.getQuietStartup())) {
             const modelList = scopedModels
                 .map((sm) => {
@@ -633,8 +539,7 @@ export async function main(args) {
                 .join(", ");
             console.log(chalk.dim(`Model scope: ${modelList} ${chalk.gray("(Ctrl+P to cycle)")}`));
         }
-        printTimings();
-        const mode = new InteractiveMode(session, {
+        const interactiveMode = new InteractiveMode(runtime, {
             migratedProviders,
             modelFallbackMessage,
             initialMessage,
@@ -642,20 +547,37 @@ export async function main(args) {
             initialMessages: parsed.messages,
             verbose: parsed.verbose,
         });
-        await mode.run();
+        if (startupBenchmark) {
+            await interactiveMode.init();
+            time("interactiveMode.init");
+            printTimings();
+            interactiveMode.stop();
+            stopThemeWatcher();
+            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 {
-        await runPrintMode(session, {
-            mode,
+        printTimings();
+        const exitCode = await runPrintMode(runtime, {
+            mode: toPrintOutputMode(appMode),
             messages: parsed.messages,
             initialMessage,
             initialImages,
         });
         stopThemeWatcher();
-        if (process.stdout.writableLength > 0) {
-            await new Promise((resolve) => process.stdout.once("drain", resolve));
+        restoreStdout();
+        if (exitCode !== 0) {
+            process.exitCode = exitCode;
         }
-        process.exit(0);
+        return;
     }
 }
 //# sourceMappingURL=main.js.map