@quantum-ai/gemini-cli 0.45.8 → 0.45.9

package/dist/config/config.js

@@ -0,0 +1,936 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import yargs from 'yargs';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const pkg = require('../../package.json');
+import { hideBin } from 'yargs/helpers';
+import process from 'node:process';
+import * as path from 'node:path';
+import { execa } from 'execa';
+import { mcpCommand } from '../commands/mcp.js';
+import { extensionsCommand } from '../commands/extensions.js';
+import { skillsCommand } from '../commands/skills.js';
+import { hooksCommand } from '../commands/hooks.js';
+import { gemmaCommand } from '../commands/gemma.js';
+import { setGeminiMdFilename as setServerGeminiMdFilename, resetGeminiMdFilename, DEFAULT_CONTEXT_FILENAME, ApprovalMode, DEFAULT_GEMINI_EMBEDDING_MODEL, DEFAULT_FILE_FILTERING_OPTIONS, FileDiscoveryService, resolveTelemetrySettings, FatalConfigError, getErrorMessage, getPty, debugLogger, ASK_USER_TOOL_NAME, getVersion, coreEvents, GEMINI_MODEL_ALIAS_AUTO, getAdminErrorMessage, isHeadlessMode, Config, SimpleExtensionLoader, resolveToRealPath, applyAdminAllowlist, applyRequiredServers, getAdminBlockedMcpServersMessage, getProjectRootForWorktree, isGeminiWorktree, detectIdeFromEnv, } from '@google/gemini-cli-core';
+import { saveModelChange, loadSettings, isWorktreeEnabled, SettingScope, } from './settings.js';
+import { loadSandboxConfig } from './sandboxConfig.js';
+import { resolvePath } from '../utils/resolvePath.js';
+import { isRecord } from '../utils/settingsUtils.js';
+import { RESUME_LATEST } from '../utils/sessionUtils.js';
+import { isWorkspaceTrusted } from './trustedFolders.js';
+import { createPolicyEngineConfig, resolveWorkspacePolicyState, } from './policy.js';
+import { ExtensionManager } from './extension-manager.js';
+import { McpServerEnablementManager } from './mcp/mcpServerEnablement.js';
+import { requestConsentNonInteractive } from './extensions/consent.js';
+import { promptForSetting } from './extensions/extensionSettings.js';
+import { runExitCleanup } from '../utils/cleanup.js';
+/**
+ * Helper to coerce comma-separated or multiple flag values into a flat array.
+ */
+const coerceCommaSeparated = (values) => {
+    if (values.length === 1 && values[0] === '') {
+        return [''];
+    }
+    return values.flatMap((v) => v
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean));
+};
+/**
+ * Pre-parses the command line arguments to find the worktree flag.
+ * Used for early setup before full argument parsing with settings.
+ */
+export function getWorktreeArg(argv) {
+    const result = yargs(hideBin(argv))
+        .help(false)
+        .version(false)
+        .option('worktree', { alias: 'w', type: 'string' })
+        .strict(false)
+        .exitProcess(false)
+        .parseSync();
+    if (result.worktree === undefined)
+        return undefined;
+    return typeof result.worktree === 'string' ? result.worktree.trim() : '';
+}
+/**
+ * Checks if a worktree is requested via CLI and enabled in settings.
+ * Returns the requested name (can be empty string for auto-generated) or undefined.
+ */
+export function getRequestedWorktreeName(settings) {
+    if (!isWorktreeEnabled(settings)) {
+        return undefined;
+    }
+    return getWorktreeArg(process.argv);
+}
+export async function parseArguments(settings) {
+    const rawArgv = hideBin(process.argv);
+    const startupMessages = [];
+    const yargsInstance = yargs(rawArgv)
+        .locale('en')
+        .scriptName('gemini')
+        .usage('Usage: gemini [options] [command]\n\nGemini CLI - Defaults to interactive mode. Use -p/--prompt for non-interactive (headless) mode.')
+        .option('isCommand', {
+        type: 'boolean',
+        hidden: true,
+        description: 'Internal flag to indicate if a subcommand is being run',
+    })
+        .option('debug', {
+        alias: 'd',
+        type: 'boolean',
+        description: 'Run in debug mode (open debug console with F12)',
+        default: false,
+    })
+        .middleware((argv) => {
+        const commandModules = [
+            mcpCommand,
+            extensionsCommand,
+            skillsCommand,
+            hooksCommand,
+            gemmaCommand,
+        ];
+        const subcommands = commandModules.flatMap((mod) => {
+            const names = [];
+            const cmd = mod.command;
+            if (cmd) {
+                if (Array.isArray(cmd)) {
+                    for (const c of cmd) {
+                        names.push(String(c).split(' ')[0]);
+                    }
+                }
+                else {
+                    names.push(String(cmd).split(' ')[0]);
+                }
+            }
+            const aliases = mod.aliases;
+            if (aliases) {
+                if (Array.isArray(aliases)) {
+                    for (const a of aliases) {
+                        names.push(String(a).split(' ')[0]);
+                    }
+                }
+                else {
+                    names.push(String(aliases).split(' ')[0]);
+                }
+            }
+            return names;
+        });
+        const firstArg = argv._[0];
+        if (typeof firstArg === 'string' && subcommands.includes(firstArg)) {
+            argv['isCommand'] = true;
+        }
+    }, true)
+        // Ensure validation flows through .fail() for clean UX
+        .fail((msg, err) => {
+        if (err)
+            throw err;
+        throw new Error(msg);
+    })
+        .check((argv) => {
+        // The 'query' positional can be a string (for one arg) or string[] (for multiple).
+        // This guard safely checks if any positional argument was provided.
+        const queryArg = argv['query'];
+        const query = typeof queryArg === 'string' || Array.isArray(queryArg)
+            ? queryArg
+            : undefined;
+        const hasPositionalQuery = Array.isArray(query)
+            ? query.length > 0
+            : !!query;
+        const sessionFlags = [
+            argv['resume'] !== undefined,
+            argv['session-id'] !== undefined,
+            argv['session-file'] !== undefined,
+        ].filter(Boolean).length;
+        if (sessionFlags > 1) {
+            return 'The flags --resume, --session-id, and --session-file are mutually exclusive. Please provide only one.';
+        }
+        if (argv['prompt'] && hasPositionalQuery) {
+            return 'Cannot use both a positional prompt and the --prompt (-p) flag together';
+        }
+        if (argv['prompt'] && argv['promptInteractive']) {
+            return 'Cannot use both --prompt (-p) and --prompt-interactive (-i) together';
+        }
+        if (argv['yolo'] && argv['approvalMode']) {
+            return 'Cannot use both --yolo (-y) and --approval-mode together. Use --approval-mode=yolo instead.';
+        }
+        const outputFormat = argv['outputFormat'];
+        if (typeof outputFormat === 'string' &&
+            !['text', 'json', 'stream-json'].includes(outputFormat)) {
+            return `Invalid values:\n  Argument: output-format, Given: "${outputFormat}", Choices: "text", "json", "stream-json"`;
+        }
+        if (argv['worktree'] && !settings.experimental?.worktrees) {
+            return 'The --worktree flag is only available when experimental.worktrees is enabled in your settings.';
+        }
+        return true;
+    });
+    yargsInstance.command(mcpCommand);
+    yargsInstance.command(extensionsCommand);
+    yargsInstance.command(skillsCommand);
+    yargsInstance.command(hooksCommand);
+    yargsInstance.command(gemmaCommand);
+    yargsInstance
+        .command('$0 [query..]', 'Launch Gemini CLI', (yargsInstance) => yargsInstance
+        .positional('query', {
+        description: 'Initial prompt. Runs in interactive mode by default; use -p/--prompt for non-interactive.',
+    })
+        .option('model', {
+        alias: 'm',
+        type: 'string',
+        nargs: 1,
+        description: `Model`,
+    })
+        .option('prompt', {
+        alias: 'p',
+        type: 'string',
+        nargs: 1,
+        description: 'Run in non-interactive (headless) mode with the given prompt. Appended to input on stdin (if any).',
+    })
+        .option('prompt-interactive', {
+        alias: 'i',
+        type: 'string',
+        nargs: 1,
+        description: 'Execute the provided prompt and continue in interactive mode',
+    })
+        .option('skip-trust', {
+        type: 'boolean',
+        description: 'Trust the current workspace for this session.',
+        default: false,
+    })
+        .option('tui', {
+        type: 'boolean',
+        description: 'Start in TUI (text user interface) mode and skip the initial prompt/question.',
+        default: false,
+    })
+        .option('worktree', {
+        alias: 'w',
+        type: 'string',
+        skipValidation: true,
+        description: 'Start Gemini in a new git worktree. If no name is provided, one is generated automatically.',
+        coerce: (value) => {
+            const trimmed = typeof value === 'string' ? value.trim() : '';
+            if (trimmed === '') {
+                return Math.random().toString(36).substring(2, 10);
+            }
+            return trimmed;
+        },
+    })
+        .option('sandbox', {
+        alias: 's',
+        type: 'boolean',
+        description: 'Run in sandbox?',
+    })
+        .option('yolo', {
+        alias: 'y',
+        type: 'boolean',
+        description: 'Automatically accept all actions (aka YOLO mode, see https://www.youtube.com/watch?v=xvFZjo5PgG0 for more details)?',
+        default: false,
+    })
+        .option('approval-mode', {
+        type: 'string',
+        nargs: 1,
+        choices: ['default', 'auto_edit', 'yolo', 'plan'],
+        description: 'Set the approval mode: default (prompt for approval), auto_edit (auto-approve edit tools), yolo (auto-approve all tools), plan (read-only mode)',
+    })
+        .option('policy', {
+        type: 'array',
+        string: true,
+        nargs: 1,
+        description: 'Additional policy files or directories to load (comma-separated or multiple --policy)',
+        coerce: coerceCommaSeparated,
+    })
+        .option('admin-policy', {
+        type: 'array',
+        string: true,
+        nargs: 1,
+        description: 'Additional admin policy files or directories to load (comma-separated or multiple --admin-policy)',
+        coerce: coerceCommaSeparated,
+    })
+        .option('acp', {
+        type: 'boolean',
+        description: 'Starts the agent in ACP mode',
+    })
+        .option('experimental-acp', {
+        type: 'boolean',
+        description: 'Starts the agent in ACP mode (deprecated, use --acp instead)',
+    })
+        .option('allowed-mcp-server-names', {
+        type: 'array',
+        string: true,
+        nargs: 1,
+        description: 'Allowed MCP server names',
+        coerce: coerceCommaSeparated,
+    })
+        .option('allowed-tools', {
+        type: 'array',
+        string: true,
+        nargs: 1,
+        description: '[DEPRECATED: Use Policy Engine instead See https://geminicli.com/docs/core/policy-engine] Tools that are allowed to run without confirmation',
+        coerce: coerceCommaSeparated,
+    })
+        .option('extensions', {
+        alias: 'e',
+        type: 'array',
+        string: true,
+        nargs: 1,
+        description: 'A list of extensions to use. If not provided, all extensions are used.',
+        coerce: coerceCommaSeparated,
+    })
+        .option('list-extensions', {
+        alias: 'l',
+        type: 'boolean',
+        description: 'List all available extensions and exit.',
+    })
+        .option('resume', {
+        alias: 'r',
+        type: 'string',
+        // `skipValidation` so that we can distinguish between it being passed with a value, without
+        // one, and not being passed at all.
+        skipValidation: true,
+        description: 'Resume a previous session. Use "latest" for most recent or index number (e.g. --resume 5)',
+        coerce: (value) => {
+            // When --resume passed with a value (`gemini --resume 123`): value = "123" (string)
+            // When --resume passed without a value (`gemini --resume`): value = "" (string)
+            // When --resume not passed at all: this `coerce` function is not called at all, and
+            //   `yargsInstance.argv.resume` is undefined.
+            const trimmed = value.trim();
+            if (trimmed === '') {
+                return RESUME_LATEST;
+            }
+            return trimmed;
+        },
+    })
+        .option('session-file', {
+        type: 'string',
+        nargs: 1,
+        description: 'Load a session from a JSON file',
+    })
+        .option('session-id', {
+        type: 'string',
+        nargs: 1,
+        description: 'Start a new session with a manually provided UUID.',
+        coerce: (value) => {
+            const trimmed = value.trim();
+            if (!trimmed) {
+                throw new Error('The --session-id option cannot be empty.');
+            }
+            if (!/^[a-zA-Z0-9-_]+$/.test(trimmed)) {
+                throw new Error('Invalid session ID "' +
+                    trimmed +
+                    '": Only alphanumeric characters, dashes, and underscores are allowed.');
+            }
+            return trimmed;
+        },
+    })
+        .option('list-sessions', {
+        type: 'boolean',
+        description: 'List available sessions for the current project and exit.',
+    })
+        .option('delete-session', {
+        type: 'string',
+        description: 'Delete a session by index number (use --list-sessions to see available sessions).',
+    })
+        .option('include-directories', {
+        type: 'array',
+        string: true,
+        nargs: 1,
+        description: 'Additional directories to include in the workspace (comma-separated or multiple --include-directories)',
+        coerce: coerceCommaSeparated,
+    })
+        .option('screen-reader', {
+        type: 'boolean',
+        description: 'Enable screen reader mode for accessibility.',
+    })
+        .option('output-format', {
+        alias: 'o',
+        type: 'string',
+        nargs: 1,
+        description: 'The format of the CLI output.',
+        choices: ['text', 'json', 'stream-json'],
+    })
+        .option('fake-responses', {
+        type: 'string',
+        description: 'Path to a file with fake model responses for testing.',
+        hidden: true,
+    })
+        .option('fake-responses-non-strict', {
+        type: 'string',
+        description: 'Path to a file with fake model responses for testing (non-strict mode).',
+        hidden: true,
+    })
+        .option('record-responses', {
+        type: 'string',
+        description: 'Path to a file to record model responses for testing.',
+        hidden: true,
+    })
+        .option('raw-output', {
+        type: 'boolean',
+        description: 'Disable sanitization of model output (e.g. allow ANSI escape sequences). WARNING: This can be a security risk if the model output is untrusted.',
+    })
+        .option('accept-raw-output-risk', {
+        type: 'boolean',
+        description: 'Suppress the security warning when using --raw-output.',
+    }))
+        .version(pkg.version) // This will enable the --version flag based on package.json
+        .alias('v', 'version')
+        .help(false)
+        .alias('h', 'help')
+        .strict()
+        .demandCommand(0, 0) // Allow base command to run with no subcommands
+        .exitProcess(false);
+    yargsInstance.wrap(yargsInstance.terminalWidth());
+    let result;
+    try {
+        const parsed = await yargsInstance.parse();
+        if (!isRecord(parsed)) {
+            throw new Error('Failed to parse arguments');
+        }
+        result = parsed;
+        if (result['skip-trust']) {
+            process.env['GEMINI_CLI_TRUST_WORKSPACE'] = 'true';
+        }
+    }
+    catch (e) {
+        const msg = getErrorMessage(e);
+        debugLogger.error(msg);
+        yargsInstance.showHelp();
+        await runExitCleanup();
+        process.exit(1);
+    }
+    // Handle help and version flags manually since we disabled exitProcess
+    if (result['help']) {
+        yargsInstance.showHelp();
+        await runExitCleanup();
+        process.exit(0);
+    }
+    if (result['version']) {
+        yargsInstance.showVersion();
+        await runExitCleanup();
+        process.exit(0);
+    }
+    // Normalize query args: handle both quoted "@path file" and unquoted @path file
+    const queryArg = result['query'];
+    let q;
+    if (Array.isArray(queryArg)) {
+        q = queryArg.join(' ');
+    }
+    else if (typeof queryArg === 'string') {
+        q = queryArg;
+    }
+    // -p/--prompt forces non-interactive mode; positional args default to interactive in TTY
+    if (q && !result['prompt']) {
+        if (!isHeadlessMode()) {
+            startupMessages.push('Positional arguments now default to interactive mode. To run in non-interactive mode, use the --prompt (-p) flag.');
+            result['promptInteractive'] = q;
+        }
+        else {
+            result['prompt'] = q;
+        }
+    }
+    // Keep CliArgs.query as a string for downstream typing
+    result['query'] = q || undefined;
+    result['startupMessages'] = startupMessages;
+    // The import format is now only controlled by settings.memoryImportFormat
+    // We no longer accept it as a CLI argument
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return result;
+}
+export function isDebugMode(argv) {
+    return (argv.debug ||
+        [process.env['DEBUG'], process.env['DEBUG_MODE']].some((v) => v === 'true' || v === '1'));
+}
+export async function loadCliConfig(settings, sessionId, argv, options = {}) {
+    const { cwd = process.cwd(), projectHooks, skipExtensions = false, loadedSettings, } = options;
+    const debugMode = isDebugMode(argv);
+    const worktreeSettings = options.worktreeSettings ?? (await resolveWorktreeSettings(cwd));
+    if (argv.sandbox) {
+        process.env['GEMINI_SANDBOX'] = 'true';
+    }
+    const includeDirectoryTree = settings.context?.includeDirectoryTree ?? true;
+    const ideMode = settings.ide?.enabled ?? false;
+    const folderTrust = process.env['GEMINI_CLI_INTEGRATION_TEST'] === 'true' ||
+        process.env['VITEST'] === 'true'
+        ? false
+        : (settings.security?.folderTrust?.enabled ?? false);
+    const trustedFolder = isWorkspaceTrusted(settings, cwd, {
+        prompt: argv.prompt,
+        query: argv.query,
+    })?.isTrusted ?? false;
+    // Set the context filename in the server's memory file helpers before loading memory
+    // TODO(b/343434939): This is a bit of a hack. The contextFileName should ideally be passed
+    // directly to the Config constructor in core, and have core handle setGeminiMdFilename.
+    // However, loadHierarchicalGeminiMemory is called *before* createServerConfig.
+    if (settings.context?.fileName) {
+        setServerGeminiMdFilename(settings.context.fileName);
+    }
+    else {
+        // Reset to default if not provided in settings.
+        resetGeminiMdFilename(DEFAULT_CONTEXT_FILENAME);
+    }
+    const fileService = new FileDiscoveryService(cwd);
+    const fileFiltering = {
+        ...DEFAULT_FILE_FILTERING_OPTIONS,
+        ...settings.context?.fileFiltering,
+    };
+    //changes the includeDirectories to be absolute paths based on the cwd, and also include any additional directories specified via CLI args
+    const includeDirectories = (settings.context?.includeDirectories || [])
+        .map(resolvePath)
+        .concat((argv.includeDirectories || []).map(resolvePath));
+    // When running inside VSCode with multiple workspace folders,
+    // automatically add the other folders as include directories
+    // so Gemini has context of all open folders, not just the cwd.
+    const ideWorkspacePath = process.env['GEMINI_CLI_IDE_WORKSPACE_PATH'];
+    if (ideWorkspacePath) {
+        const realCwd = resolveToRealPath(cwd);
+        const ideFolders = ideWorkspacePath.split(path.delimiter).filter((p) => {
+            const trimmedPath = p.trim();
+            if (!trimmedPath)
+                return false;
+            try {
+                return resolveToRealPath(trimmedPath) !== realCwd;
+            }
+            catch (e) {
+                debugLogger.debug(`[IDE] Skipping inaccessible workspace folder: ${trimmedPath} (${getErrorMessage(e)})`);
+                return false;
+            }
+        });
+        includeDirectories.push(...ideFolders);
+    }
+    let extensionManager;
+    if (!skipExtensions) {
+        extensionManager = new ExtensionManager({
+            settings,
+            requestConsent: requestConsentNonInteractive,
+            requestSetting: promptForSetting,
+            workspaceDir: cwd,
+            enabledExtensionOverrides: argv.extensions,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            eventEmitter: coreEvents,
+            clientVersion: await getVersion(),
+        });
+        await extensionManager.loadExtensions();
+    }
+    const extensionPlanSettings = extensionManager
+        ?.getExtensions()
+        ?.find((ext) => ext.isActive && ext.plan?.directory)?.plan;
+    let extensionRegistryURI = process.env['GEMINI_CLI_EXTENSION_REGISTRY_URI'] ??
+        (trustedFolder ? settings.experimental?.extensionRegistryURI : undefined);
+    if (extensionRegistryURI && !extensionRegistryURI.startsWith('http')) {
+        extensionRegistryURI = resolveToRealPath(path.resolve(cwd, resolvePath(extensionRegistryURI)));
+    }
+    const finalExtensionLoader = extensionManager ?? new SimpleExtensionLoader([]);
+    // If --tui is specified, skip the initial question/prompt
+    const question = argv.tui ? '' : (argv.promptInteractive || argv.prompt || '');
+    // Determine approval mode with backward compatibility
+    let approvalMode;
+    const rawApprovalMode = argv.approvalMode ||
+        (argv.yolo ? 'yolo' : undefined) ||
+        (settings.general?.defaultApprovalMode !== 'yolo'
+            ? settings.general?.defaultApprovalMode
+            : undefined);
+    if (rawApprovalMode) {
+        switch (rawApprovalMode) {
+            case 'yolo':
+                approvalMode = ApprovalMode.YOLO;
+                break;
+            case 'auto_edit':
+                approvalMode = ApprovalMode.AUTO_EDIT;
+                break;
+            case 'plan':
+                if (!(settings.general?.plan?.enabled ?? true)) {
+                    debugLogger.warn('Approval mode "plan" is disabled in your settings. Falling back to "default".');
+                    approvalMode = ApprovalMode.DEFAULT;
+                }
+                else {
+                    approvalMode = ApprovalMode.PLAN;
+                }
+                break;
+            case 'default':
+                approvalMode = ApprovalMode.DEFAULT;
+                break;
+            default:
+                throw new Error(`Invalid approval mode: ${rawApprovalMode}. Valid values are: yolo, auto_edit, plan, default`);
+        }
+    }
+    else {
+        approvalMode = ApprovalMode.DEFAULT;
+    }
+    // Override approval mode if disableYoloMode is set.
+    if (settings.security?.disableYoloMode || settings.admin?.secureModeEnabled) {
+        if (approvalMode === ApprovalMode.YOLO) {
+            if (settings.admin?.secureModeEnabled) {
+                debugLogger.error('YOLO mode is disabled by "secureModeEnabled" setting.');
+            }
+            else {
+                debugLogger.error('YOLO mode is disabled by the "disableYolo" setting.');
+            }
+            throw new FatalConfigError(getAdminErrorMessage('YOLO mode', undefined /* config */));
+        }
+    }
+    else if (approvalMode === ApprovalMode.YOLO) {
+        debugLogger.warn('YOLO mode is enabled. All tool calls will be automatically approved.');
+    }
+    // Force approval mode to default if the folder is not trusted, unless YOLO mode is explicitly set.
+    if (!trustedFolder && approvalMode !== ApprovalMode.DEFAULT && approvalMode !== ApprovalMode.YOLO) {
+        debugLogger.warn(`Approval mode overridden to "default" because the current folder is not trusted.`);
+        approvalMode = ApprovalMode.DEFAULT;
+    }
+    let telemetrySettings;
+    try {
+        telemetrySettings = await resolveTelemetrySettings({
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            env: process.env,
+            settings: settings.telemetry,
+        });
+    }
+    catch (err) {
+        if (err instanceof FatalConfigError) {
+            throw new FatalConfigError(`Invalid telemetry configuration: ${err.message}.`);
+        }
+        throw err;
+    }
+    // -p/--prompt forces non-interactive (headless) mode
+    // -i/--prompt-interactive forces interactive mode with an initial prompt
+    // --tui forces interactive mode without initial prompt
+    const interactive = !!argv.tui ||
+        !!argv.promptInteractive ||
+        !!argv.acp ||
+        !!argv.experimentalAcp ||
+        (!isHeadlessMode({ prompt: argv.prompt, query: argv.query }) &&
+            !argv.isCommand);
+    // If TUI mode is enabled, hide tips to skip initial "getting started" prompts.
+    if (argv.tui && options.loadedSettings) {
+        options.loadedSettings.setValue(SettingScope.User, 'ui.hideTips', true);
+    }
+    const allowedTools = argv.allowedTools || settings.tools?.allowed || [];
+    const isAcpMode = !!argv.acp || !!argv.experimentalAcp;
+    // In non-interactive mode, exclude tools that require a prompt.
+    const extraExcludes = [];
+    if (!interactive || isAcpMode) {
+        // The Policy Engine natively handles headless safety by translating ASK_USER
+        // decisions to DENY. However, we explicitly block ask_user here to guarantee
+        // it can never be allowed via a high-priority policy rule when no human is present.
+        // We also exclude it in ACP mode as IDEs intercept tool calls and ask for permission,
+        // breaking conversational flows.
+        extraExcludes.push(ASK_USER_TOOL_NAME);
+    }
+    const excludeTools = mergeExcludeTools(settings, extraExcludes);
+    // Create a settings object that includes CLI overrides for policy generation
+    const effectiveSettings = {
+        ...settings,
+        tools: {
+            ...settings.tools,
+            allowed: allowedTools,
+            exclude: excludeTools,
+        },
+        mcp: {
+            ...settings.mcp,
+            allowed: argv.allowedMcpServerNames ?? settings.mcp?.allowed,
+        },
+        policyPaths: (argv.policy ?? settings.policyPaths)?.map((p) => resolvePath(p)),
+        adminPolicyPaths: (argv.adminPolicy ?? settings.adminPolicyPaths)?.map((p) => resolvePath(p)),
+    };
+    const { workspacePoliciesDir, policyUpdateConfirmationRequest } = await resolveWorkspacePolicyState({
+        cwd,
+        trustedFolder,
+        interactive,
+    });
+    const policyEngineConfig = await createPolicyEngineConfig(effectiveSettings, approvalMode, workspacePoliciesDir, interactive);
+    const defaultModel = GEMINI_MODEL_ALIAS_AUTO;
+    const rawModel = argv.model ||
+        process.env['OPENAI_MODEL'] ||
+        process.env['GEMINI_MODEL'] ||
+        settings.model?.name;
+    // Ensure specifiedModel is a string (e.g. if yargs parsed multiple --model as an array)
+    const specifiedModel = Array.isArray(rawModel)
+        ? String(rawModel.at(-1) ?? '').trim() || ''
+        : rawModel === undefined
+            ? undefined
+            : String(rawModel ?? '').trim() || '';
+    const resolvedModel = specifiedModel === GEMINI_MODEL_ALIAS_AUTO
+        ? defaultModel
+        : specifiedModel || defaultModel;
+    const sandboxConfig = await loadSandboxConfig(settings, argv);
+    if (sandboxConfig) {
+        const existingPaths = sandboxConfig.allowedPaths || [];
+        if (settings.tools.sandboxAllowedPaths?.length) {
+            sandboxConfig.allowedPaths = [
+                ...new Set([...existingPaths, ...settings.tools.sandboxAllowedPaths]),
+            ];
+        }
+        if (settings.tools.sandboxNetworkAccess !== undefined) {
+            sandboxConfig.networkAccess =
+                sandboxConfig.networkAccess || settings.tools.sandboxNetworkAccess;
+        }
+    }
+    const screenReader = argv.screenReader !== undefined
+        ? argv.screenReader
+        : (settings.ui?.accessibility?.screenReader ?? false);
+    const ptyInfo = await getPty();
+    const mcpEnabled = settings.admin?.mcp?.enabled ?? true;
+    const extensionsEnabled = settings.admin?.extensions?.enabled ?? true;
+    const adminSkillsEnabled = settings.admin?.skills?.enabled ?? true;
+    // Create MCP enablement manager and callbacks
+    const mcpEnablementManager = McpServerEnablementManager.getInstance();
+    const mcpEnablementCallbacks = mcpEnabled
+        ? mcpEnablementManager.getEnablementCallbacks()
+        : undefined;
+    const adminAllowlist = settings.admin?.mcp?.config;
+    let mcpServerCommand = mcpEnabled ? settings.mcp?.serverCommand : undefined;
+    let mcpServers = mcpEnabled ? settings.mcpServers : {};
+    if (mcpEnabled && adminAllowlist && Object.keys(adminAllowlist).length > 0) {
+        const result = applyAdminAllowlist(mcpServers, adminAllowlist);
+        mcpServers = result.mcpServers;
+        mcpServerCommand = undefined;
+        if (result.blockedServerNames && result.blockedServerNames.length > 0) {
+            const message = getAdminBlockedMcpServersMessage(result.blockedServerNames, undefined);
+            coreEvents.emitConsoleLog('warn', message);
+        }
+    }
+    // Apply admin-required MCP servers (injected regardless of allowlist)
+    if (mcpEnabled) {
+        const requiredMcpConfig = settings.admin?.mcp?.requiredConfig;
+        if (requiredMcpConfig && Object.keys(requiredMcpConfig).length > 0) {
+            const requiredResult = applyRequiredServers(mcpServers ?? {}, requiredMcpConfig);
+            mcpServers = requiredResult.mcpServers;
+            if (requiredResult.requiredServerNames.length > 0) {
+                coreEvents.emitConsoleLog('info', `Admin-required MCP servers injected: ${requiredResult.requiredServerNames.join(', ')}`);
+            }
+        }
+    }
+    let clientName = undefined;
+    if (isAcpMode) {
+        const ide = detectIdeFromEnv();
+        if (ide &&
+            (ide.name !== 'vscode' || process.env['TERM_PROGRAM'] === 'vscode')) {
+            clientName = `acp-${ide.name}`;
+        }
+        else {
+            clientName = 'acp';
+        }
+    }
+    else if (argv.isCommand) {
+        clientName = 'cli-command';
+    }
+    else {
+        clientName = 'tui';
+    }
+    // TODO(joshualitt): Clean this up alongside removal of the legacy config.
+    let profileSelector = undefined;
+    if (settings.experimental?.stressTestProfile) {
+        profileSelector = 'stressTestProfile';
+    }
+    else if (settings.experimental?.powerUserProfile) {
+        profileSelector = 'powerUserProfile';
+    }
+    else if (settings.experimental?.generalistProfile ||
+        settings.experimental?.contextManagement) {
+        profileSelector = 'generalistProfile';
+    }
+    const contextManagement = {
+        enabled: !!profileSelector,
+    };
+    return new Config({
+        acpMode: isAcpMode,
+        clientName,
+        sessionId,
+        clientVersion: await getVersion(),
+        embeddingModel: DEFAULT_GEMINI_EMBEDDING_MODEL,
+        sandbox: sandboxConfig,
+        toolSandboxing: settings.security?.toolSandboxing ?? false,
+        targetDir: cwd,
+        includeDirectoryTree,
+        includeDirectories,
+        loadMemoryFromIncludeDirectories: settings.context?.loadMemoryFromIncludeDirectories || false,
+        discoveryMaxDirs: settings.context?.discoveryMaxDirs,
+        memoryBoundaryMarkers: settings.context?.memoryBoundaryMarkers,
+        importFormat: settings.context?.importFormat,
+        debugMode,
+        question,
+        worktreeSettings,
+        coreTools: settings.tools?.core || undefined,
+        experimentalContextManagementConfig: profileSelector,
+        allowedTools: allowedTools.length > 0 ? allowedTools : undefined,
+        policyEngineConfig,
+        policyUpdateConfirmationRequest,
+        excludeTools,
+        toolDiscoveryCommand: settings.tools?.discoveryCommand,
+        toolCallCommand: settings.tools?.callCommand,
+        mcpServerCommand,
+        mcpServers,
+        mcpEnablementCallbacks,
+        mcpEnabled,
+        extensionsEnabled,
+        agents: settings.agents,
+        adminSkillsEnabled,
+        allowedMcpServers: mcpEnabled
+            ? (argv.allowedMcpServerNames ??
+                (loadedSettings
+                    ? loadedSettings.getConsolidatedAllowedMcpServers()
+                    : settings.mcp?.allowed))
+            : undefined,
+        blockedMcpServers: mcpEnabled
+            ? argv.allowedMcpServerNames
+                ? undefined
+                : loadedSettings
+                    ? loadedSettings.getConsolidatedExcludedMcpServers()
+                    : settings.mcp?.excluded
+            : undefined,
+        blockedEnvironmentVariables: settings.security?.environmentVariableRedaction?.blocked,
+        allowedEnvironmentVariables: settings.security?.environmentVariableRedaction?.allowed,
+        enableEnvironmentVariableRedaction: settings.security?.environmentVariableRedaction?.enabled,
+        approvalMode,
+        disableYoloMode: settings.security?.disableYoloMode || settings.admin?.secureModeEnabled,
+        disableAlwaysAllow: settings.security?.disableAlwaysAllow ||
+            settings.admin?.secureModeEnabled,
+        showMemoryUsage: settings.ui?.showMemoryUsage || false,
+        accessibility: {
+            ...settings.ui?.accessibility,
+            screenReader,
+        },
+        telemetry: telemetrySettings,
+        usageStatisticsEnabled: settings.privacy?.usageStatisticsEnabled,
+        fileFiltering,
+        checkpointing: settings.general?.checkpointing?.enabled,
+        proxy: process.env['HTTPS_PROXY'] ||
+            process.env['https_proxy'] ||
+            process.env['HTTP_PROXY'] ||
+            process.env['http_proxy'],
+        cwd,
+        fileDiscoveryService: fileService,
+        bugCommand: settings.advanced?.bugCommand,
+        model: resolvedModel,
+        maxSessionTurns: settings.model?.maxSessionTurns,
+        listExtensions: argv.listExtensions || false,
+        listSessions: argv.listSessions || false,
+        deleteSession: argv.deleteSession,
+        enabledExtensions: argv.extensions,
+        extensionLoader: finalExtensionLoader,
+        extensionRegistryURI,
+        enableExtensionReloading: settings.experimental?.extensionReloading,
+        enableAgents: settings.experimental?.enableAgents,
+        plan: settings.general?.plan?.enabled ?? true,
+        voiceMode: settings.experimental?.voiceMode,
+        tracker: settings.experimental?.taskTracker,
+        directWebFetch: settings.experimental?.directWebFetch,
+        planSettings: settings.general?.plan?.directory
+            ? settings.general.plan
+            : (extensionPlanSettings ?? settings.general?.plan),
+        enableEventDrivenScheduler: true,
+        skillsSupport: settings.skills?.enabled ?? true,
+        disabledSkills: settings.skills?.disabled,
+        experimentalAutoMemory: settings.experimental?.autoMemory,
+        experimentalGemma: settings.experimental?.gemma,
+        contextManagement,
+        modelSteering: settings.experimental?.modelSteering,
+        topicUpdateNarration: settings.general?.topicUpdateNarration ??
+            settings.experimental?.topicUpdateNarration,
+        noBrowser: !!process.env['NO_BROWSER'],
+        summarizeToolOutput: settings.model?.summarizeToolOutput,
+        ideMode,
+        disableLoopDetection: settings.model?.disableLoopDetection,
+        compressionThreshold: settings.model?.compressionThreshold,
+        folderTrust,
+        interactive,
+        trustedFolder,
+        useBackgroundColor: settings.ui?.useBackgroundColor,
+        useAlternateBuffer: settings.ui?.useAlternateBuffer,
+        useTerminalBuffer: settings.ui?.terminalBuffer,
+        useRenderProcess: settings.ui?.renderProcess,
+        useRipgrep: settings.tools?.useRipgrep,
+        enableInteractiveShell: settings.tools?.shell?.enableInteractiveShell,
+        shellBackgroundCompletionBehavior: settings.tools?.shell
+            ?.backgroundCompletionBehavior,
+        shellToolInactivityTimeout: settings.tools?.shell?.inactivityTimeout,
+        enableShellOutputEfficiency: settings.tools?.shell?.enableShellOutputEfficiency ?? true,
+        // In ACP mode, always skip the next-speaker check. This check triggers
+        // recursive continuation turns inside GeminiClient.processTurn() that
+        // conflict with ACP's explicit turn management via session/prompt,
+        // causing infinite agent_thought_chunk loops.
+        skipNextSpeakerCheck: isAcpMode || settings.model?.skipNextSpeakerCheck,
+        truncateToolOutputThreshold: settings.tools?.truncateToolOutputThreshold,
+        eventEmitter: coreEvents,
+        useWriteTodos: argv.useWriteTodos ?? settings.useWriteTodos,
+        output: {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            format: (argv.outputFormat ?? settings.output?.format),
+        },
+        gemmaModelRouter: settings.experimental?.gemmaModelRouter,
+        adk: settings.experimental?.adk,
+        fakeResponses: argv.fakeResponses,
+        fakeResponsesNonStrict: argv.fakeResponsesNonStrict,
+        recordResponses: argv.recordResponses,
+        retryFetchErrors: settings.general?.retryFetchErrors,
+        billing: settings.billing,
+        vertexAiRouting: settings.billing?.vertexAi,
+        maxAttempts: settings.general?.maxAttempts,
+        ptyInfo: ptyInfo?.name,
+        disableLLMCorrection: settings.tools?.disableLLMCorrection,
+        rawOutput: argv.rawOutput,
+        acceptRawOutputRisk: argv.acceptRawOutputRisk,
+        dynamicModelConfiguration: settings.experimental?.dynamicModelConfiguration,
+        modelConfigServiceConfig: settings.modelConfigs,
+        // TODO: loading of hooks based on workspace trust
+        enableHooks: settings.hooksConfig.enabled,
+        enableHooksUI: settings.hooksConfig.enabled,
+        hooks: settings.hooks || {},
+        disabledHooks: settings.hooksConfig?.disabled || [],
+        projectHooks: projectHooks || {},
+        onModelChange: (model) => saveModelChange(loadSettings(cwd), model),
+        onReload: async () => {
+            const refreshedSettings = loadSettings(cwd);
+            return {
+                disabledSkills: refreshedSettings.merged.skills.disabled,
+                agents: refreshedSettings.merged.agents,
+            };
+        },
+        enableConseca: settings.security?.enableConseca,
+    });
+}
+function mergeExcludeTools(settings, extraExcludes = []) {
+    const allExcludeTools = new Set([
+        ...(settings.tools.exclude || []),
+        ...extraExcludes,
+    ]);
+    return Array.from(allExcludeTools);
+}
+async function resolveWorktreeSettings(cwd) {
+    let worktreePath;
+    try {
+        const { stdout } = await execa('git', ['rev-parse', '--show-toplevel'], {
+            cwd,
+        });
+        const toplevel = stdout.trim();
+        const projectRoot = await getProjectRootForWorktree(toplevel);
+        if (isGeminiWorktree(toplevel, projectRoot)) {
+            worktreePath = toplevel;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    if (!worktreePath) {
+        return undefined;
+    }
+    let worktreeBaseSha;
+    try {
+        const { stdout } = await execa('git', ['rev-parse', 'HEAD'], {
+            cwd: worktreePath,
+        });
+        worktreeBaseSha = stdout.trim();
+    }
+    catch (e) {
+        debugLogger.debug(`Failed to resolve worktree base SHA at ${worktreePath}: ${getErrorMessage(e)}`);
+    }
+    if (!worktreeBaseSha) {
+        return undefined;
+    }
+    return {
+        name: path.basename(worktreePath),
+        path: worktreePath,
+        baseSha: worktreeBaseSha,
+    };
+}