@mariozechner/pi-coding-agent 0.64.0 → 0.65.1

package/dist/main.js

@@ -4,32 +4,35 @@
  * This file handles CLI argument parsing and translates them into
  * createAgentSession() options. The SDK does the heavy lifting.
  */
+import { resolve } from "node:path";
 import { modelsAreEqual, supportsXhigh } from "@mariozechner/pi-ai";
+import { ProcessTerminal, setKeybindings, TUI } from "@mariozechner/pi-tui";
 import chalk from "chalk";
 import { createInterface } from "readline";
 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 { getAgentDir, getModelsPath, VERSION } from "./config.js";
+import { createAgentSessionRuntime } from "./core/agent-session-runtime.js";
+import { createAgentSessionFromServices, createAgentSessionServices, } from "./core/agent-session-services.js";
 import { AuthStorage } from "./core/auth-storage.js";
 import { exportFromFile } from "./core/export-html/index.js";
-import { migrateKeybindingsConfigFile } from "./core/keybindings.js";
-import { ModelRegistry } from "./core/model-registry.js";
+import { KeybindingsManager } from "./core/keybindings.js";
 import { resolveCliModel, resolveModelScope } from "./core/model-resolver.js";
 import { restoreStdout, takeOverStdout } from "./core/output-guard.js";
-import { DefaultPackageManager } from "./core/package-manager.js";
-import { DefaultResourceLoader } from "./core/resource-loader.js";
-import { createAgentSession } from "./core/sdk.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, resetTimings, time } from "./core/timings.js";
 import { allTools } from "./core/tools/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";
 /**
  * Read all content from piped stdin.
  * Returns undefined if stdin is a TTY (interactive terminal).
@@ -51,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) {
@@ -65,212 +72,20 @@ 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.
-Alias: ${APP_NAME} uninstall <source> [-l]
-
-Options:
-  -l, --local    Remove from project settings (.pi/settings.json)
-
-Examples:
-  ${APP_NAME} remove npm:@foo/bar
-  ${APP_NAME} uninstall 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 parsePackageCommand(args) {
-    const [rawCommand, ...rest] = args;
-    let command;
-    if (rawCommand === "uninstall") {
-        command = "remove";
+function resolveAppMode(parsed, stdinIsTTY) {
+    if (parsed.mode === "rpc") {
+        return "rpc";
     }
-    else if (rawCommand === "install" || rawCommand === "remove" || rawCommand === "update" || rawCommand === "list") {
-        command = rawCommand;
+    if (parsed.mode === "json") {
+        return "json";
     }
-    if (!command) {
-        return undefined;
-    }
-    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, stdinContent) {
     if (parsed.fileArgs.length === 0) {
@@ -322,29 +137,6 @@ async function promptConfirm(message) {
         });
     });
 }
-/** Helper to call CLI-only session_directory handlers before the initial session manager is created */
-async function callSessionDirectoryHook(extensions, cwd) {
-    let customSessionDir;
-    for (const ext of extensions.extensions) {
-        const handlers = ext.handlers.get("session_directory");
-        if (!handlers || handlers.length === 0)
-            continue;
-        for (const handler of handlers) {
-            try {
-                const event = { type: "session_directory", cwd };
-                const result = (await handler(event));
-                if (result?.sessionDir) {
-                    customSessionDir = result.sessionDir;
-                }
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                console.error(chalk.red(`Extension "${ext.path}" session_directory handler failed: ${message}`));
-            }
-        }
-    }
-    return customSessionDir;
-}
 function validateForkFlags(parsed) {
     if (!parsed.fork)
         return;
@@ -369,62 +161,65 @@ function forkSessionOrExit(sourcePath, cwd, sessionDir) {
         process.exit(1);
     }
 }
-async function createSessionManager(parsed, cwd, extensions, settingsManager) {
+async function createSessionManager(parsed, cwd, sessionDir, settingsManager) {
     if (parsed.noSession) {
         return SessionManager.inMemory();
     }
-    // Priority: CLI flag > settings.json > extension hook
-    const effectiveSessionDir = parsed.sessionDir ?? settingsManager.getSessionDir() ?? (await callSessionDirectoryHook(extensions, cwd));
     if (parsed.fork) {
-        const resolved = await resolveSessionPath(parsed.fork, cwd, effectiveSessionDir);
+        const resolved = await resolveSessionPath(parsed.fork, cwd, sessionDir);
         switch (resolved.type) {
             case "path":
             case "local":
             case "global":
-                return forkSessionOrExit(resolved.path, cwd, effectiveSessionDir);
+                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, effectiveSessionDir);
+        const resolved = await resolveSessionPath(parsed.session, cwd, sessionDir);
         switch (resolved.type) {
             case "path":
             case "local":
-                return SessionManager.open(resolved.path, effectiveSessionDir);
+                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 forkSessionOrExit(resolved.path, cwd, effectiveSessionDir);
+                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, effectiveSessionDir);
+    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 effective session dir is set, create new session there
-    if (effectiveSessionDir) {
-        return SessionManager.create(cwd, effectiveSessionDir);
+    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>
@@ -435,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;
@@ -451,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();
@@ -501,25 +295,31 @@ function buildSessionOptions(parsed, scopedModels, sessionManager, modelRegistry
     else if (parsed.tools) {
         options.tools = parsed.tools.map((name) => allTools[name]);
     }
-    return { options, cliThinkingFromModel };
+    return { options, cliThinkingFromModel, diagnostics };
 }
-async function handleConfigCommand(args) {
-    if (args[0] !== "config") {
-        return false;
-    }
-    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,
+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) {
     resetTimings();
@@ -534,93 +334,26 @@ export async function main(args) {
     if (await handleConfigCommand(args)) {
         return;
     }
-    // First pass: parse args to get --extension paths
-    const firstPass = parseArgs(args);
-    time("parseArgs.firstPass");
-    const shouldTakeOverStdout = firstPass.mode !== undefined || firstPass.print || !process.stdin.isTTY;
-    if (shouldTakeOverStdout) {
-        takeOverStdout();
-    }
-    // Run migrations (pass cwd for project-local migrations)
-    const { migratedAuthProviders: migratedProviders, deprecationWarnings } = runMigrations(process.cwd());
-    time("runMigrations");
-    // 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 = ModelRegistry.create(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,
-    });
-    time("createResourceLoader");
-    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, extensionPath } of extensionsResult.runtime.pendingProviderRegistrations) {
-        try {
-            modelRegistry.registerProvider(name, config);
+    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}`));
         }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            console.error(chalk.red(`Extension "${extensionPath}" error: ${message}`));
-        }
-    }
-    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 });
+        if (parsed.diagnostics.some((d) => d.type === "error")) {
+            process.exit(1);
         }
     }
-    // Second pass: parse args with extension flags
-    const parsed = parseArgs(args, extensionFlags);
-    time("parseArgs.secondPass");
-    // 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
-    let stdinContent;
-    if (parsed.mode !== "rpc") {
-        stdinContent = await readPipedStdin();
-        if (stdinContent !== undefined) {
-            // Force print mode since interactive mode requires a TTY for keyboard input
-            parsed.print = true;
-        }
-    }
-    time("readPipedStdin");
     if (parsed.export) {
         let result;
         try {
@@ -635,92 +368,178 @@ export async function main(args) {
         console.log(`Exported to: ${result}`);
         process.exit(0);
     }
-    migrateKeybindingsConfigFile(agentDir);
-    time("migrateKeybindingsConfigFile");
     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);
+    // 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 sessionDir = parsed.sessionDir ?? 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);
+        }
+    }
+    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,
+                systemPrompt: parsed.systemPrompt,
+                appendSystemPrompt: parsed.appendSystemPrompt,
+            },
+        });
+        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);
+            }
+        }
+        const created = await createAgentSessionFromServices({
+            services,
+            sessionManager,
+            sessionStartEvent,
+            model: sessionOptions.model,
+            thinkingLevel: sessionOptions.thinkingLevel,
+            scopedModels: sessionOptions.scopedModels,
+            tools: sessionOptions.tools,
+            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);
+            }
+        }
+        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";
+        }
+    }
+    time("readPipedStdin");
     const { initialMessage, initialImages } = await prepareInitialMessage(parsed, settingsManager.getImageAutoResize(), stdinContent);
     time("prepareInitialMessage");
-    const isInteractive = !parsed.print && parsed.mode === undefined;
-    const startupBenchmark = isTruthyEnvFlag(process.env.PI_STARTUP_BENCHMARK);
-    if (startupBenchmark && !isInteractive) {
-        console.error(chalk.red("Error: PI_STARTUP_BENCHMARK only supports interactive mode"));
-        process.exit(1);
-    }
-    const mode = parsed.mode || "text";
-    initTheme(settingsManager.getTheme(), isInteractive);
+    initTheme(settingsManager.getTheme(), appMode === "interactive");
     time("initTheme");
     // Show deprecation warnings in interactive mode
-    if (isInteractive && deprecationWarnings.length > 0) {
+    if (appMode === "interactive" && deprecationWarnings.length > 0) {
         await showDeprecationWarnings(deprecationWarnings);
     }
-    let scopedModels = [];
-    const modelPatterns = parsed.models ?? settingsManager.getEnabledModels();
-    if (modelPatterns && modelPatterns.length > 0) {
-        scopedModels = await resolveModelScope(modelPatterns, modelRegistry);
-    }
+    const scopedModels = [...session.scopedModels];
     time("resolveModelScope");
-    // Create session manager based on CLI flags
-    let sessionManager = await createSessionManager(parsed, cwd, extensionsResult, settingsManager);
-    time("createSessionManager");
-    // Handle --resume: show session picker
-    if (parsed.resume) {
-        // Compute effective session dir for resume (same logic as createSessionManager)
-        const effectiveSessionDir = parsed.sessionDir ??
-            settingsManager.getSessionDir() ??
-            (await callSessionDirectoryHook(extensionsResult, cwd));
-        const selectedPath = await selectSession((onProgress) => SessionManager.list(cwd, effectiveSessionDir, onProgress), SessionManager.listAll);
-        if (!selectedPath) {
-            console.log(chalk.dim("No session selected"));
-            stopThemeWatcher();
-            process.exit(0);
-        }
-        sessionManager = SessionManager.open(selectedPath, effectiveSessionDir);
-    }
-    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"));
-            process.exit(1);
-        }
-        authStorage.setRuntimeApiKey(sessionOptions.model.provider, parsed.apiKey);
+    reportDiagnostics(runtime.diagnostics);
+    if (runtime.diagnostics.some((diagnostic) => diagnostic.type === "error")) {
+        process.exit(1);
     }
-    const { session, modelFallbackMessage } = await createAgentSession(sessionOptions);
     time("createAgentSession");
-    if (!isInteractive && !session.model) {
+    if (appMode !== "interactive" && !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";
-        }
-        else if (effectiveThinking === "xhigh" && !supportsXhigh(session.model)) {
-            effectiveThinking = "high";
-        }
-        if (effectiveThinking !== session.thinkingLevel) {
-            session.setThinkingLevel(effectiveThinking);
-        }
+    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 (mode === "rpc") {
+    if (appMode === "rpc") {
         printTimings();
-        await runRpcMode(session);
+        await runRpcMode(runtime);
     }
-    else if (isInteractive) {
+    else if (appMode === "interactive") {
         if (scopedModels.length > 0 && (parsed.verbose || !settingsManager.getQuietStartup())) {
             const modelList = scopedModels
                 .map((sm) => {
@@ -730,7 +549,7 @@ export async function main(args) {
                 .join(", ");
             console.log(chalk.dim(`Model scope: ${modelList} ${chalk.gray("(Ctrl+P to cycle)")}`));
         }
-        const interactiveMode = new InteractiveMode(session, {
+        const interactiveMode = new InteractiveMode(runtime, {
             migratedProviders,
             modelFallbackMessage,
             initialMessage,
@@ -757,8 +576,8 @@ export async function main(args) {
     }
     else {
         printTimings();
-        const exitCode = await runPrintMode(session, {
-            mode,
+        const exitCode = await runPrintMode(runtime, {
+            mode: toPrintOutputMode(appMode),
             messages: parsed.messages,
             initialMessage,
             initialImages,