@georgedong32/ccs 7.66.0

package/dist/ccs.js

@@ -0,0 +1,1133 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./utils/fetch-proxy-setup");
+const fs = __importStar(require("fs"));
+const claude_detector_1 = require("./utils/claude-detector");
+const config_manager_1 = require("./utils/config-manager");
+const helpers_1 = require("./utils/helpers");
+const api_key_validator_1 = require("./utils/api-key-validator");
+const error_manager_1 = require("./utils/error-manager");
+const cliproxy_1 = require("./cliproxy");
+const env_builder_1 = require("./cliproxy/config/env-builder");
+const port_manager_1 = require("./cliproxy/config/port-manager");
+const websearch_manager_1 = require("./utils/websearch-manager");
+const image_analysis_1 = require("./utils/image-analysis");
+const unified_config_loader_1 = require("./config/unified-config-loader");
+const image_analyzer_profile_hook_injector_1 = require("./utils/hooks/image-analyzer-profile-hook-injector");
+const hooks_1 = require("./utils/hooks");
+const ui_1 = require("./utils/ui");
+const constants_1 = require("./copilot/constants");
+const official_channels_runtime_1 = require("./channels/official-channels-runtime");
+const official_channels_store_1 = require("./channels/official-channels-store");
+const constants_2 = require("./cursor/constants");
+// Import centralized error handling
+const errors_1 = require("./errors");
+const root_command_router_1 = require("./commands/root-command-router");
+// Import extracted utility functions
+const shell_executor_1 = require("./utils/shell-executor");
+const glmt_deprecation_1 = require("./utils/glmt-deprecation");
+const resume_lane_warning_1 = require("./auth/resume-lane-warning");
+// Import target adapter system
+const targets_1 = require("./targets");
+const target_resolver_1 = require("./targets/target-resolver");
+const droid_reasoning_runtime_1 = require("./targets/droid-reasoning-runtime");
+const droid_command_router_1 = require("./targets/droid-command-router");
+const cliproxy_profile_bridge_1 = require("./api/services/cliproxy-profile-bridge");
+// Version and Update check utilities
+const version_1 = require("./utils/version");
+const update_checker_1 = require("./utils/update-checker");
+const CODEX_RUNTIME_REASONING_LEVELS = new Set(['minimal', 'low', 'medium', 'high', 'xhigh']);
+const CODEX_NATIVE_PASSTHROUGH_FLAGS = new Set(['--help', '-h', '--version', '-v']);
+/**
+ * Smart profile detection
+ */
+function detectProfile(args) {
+    if (args.length === 0 || args[0].startsWith('-')) {
+        // No args or first arg is a flag → use default profile
+        return { profile: 'default', remainingArgs: args };
+    }
+    else {
+        // First arg doesn't start with '-' → treat as profile name
+        return { profile: args[0], remainingArgs: args.slice(1) };
+    }
+}
+function resolveRuntimeReasoningFlags(args, envThinkingValue) {
+    const runtime = (0, droid_reasoning_runtime_1.resolveDroidReasoningRuntime)(args, envThinkingValue);
+    if (runtime.duplicateDisplays.length > 0) {
+        console.error((0, ui_1.warn)(`[!] Multiple reasoning flags detected. Using first occurrence: ${runtime.sourceDisplay || '<first-flag>'}`));
+    }
+    return {
+        argsWithoutReasoningFlags: runtime.argsWithoutReasoningFlags,
+        reasoningOverride: runtime.reasoningOverride,
+        reasoningSource: runtime.sourceFlag
+            ? 'flag'
+            : runtime.reasoningOverride !== undefined
+                ? 'env'
+                : undefined,
+        sourceDisplay: runtime.sourceDisplay,
+    };
+}
+function normalizeCodexRuntimeReasoningOverride(value) {
+    return typeof value === 'string' && CODEX_RUNTIME_REASONING_LEVELS.has(value) ? value : undefined;
+}
+function exitWithRuntimeReasoningFlagError(message, options) {
+    console.error((0, ui_1.fail)(message));
+    console.error('    Examples: --thinking low, --thinking 8192, --thinking off');
+    console.error(`    Codex alias: --effort ${options.codexAliasLevels}`);
+    if (options.includeDroidExecExample) {
+        console.error('    Droid exec: --reasoning-effort high');
+    }
+    process.exit(1);
+}
+/**
+ * Perform background update check (refreshes cache, no notification)
+ */
+async function refreshUpdateCache() {
+    try {
+        const currentVersion = (0, version_1.getVersion)();
+        // npm is now the only supported installation method
+        await (0, update_checker_1.checkForUpdates)(currentVersion, true, 'npm');
+    }
+    catch (_e) {
+        // Silently fail - update check shouldn't crash main CLI
+    }
+}
+/**
+ * Show update notification if cached result indicates update available
+ * Returns true if notification was shown
+ */
+async function showCachedUpdateNotification() {
+    try {
+        const currentVersion = (0, version_1.getVersion)();
+        const updateInfo = (0, update_checker_1.checkCachedUpdate)(currentVersion);
+        if (updateInfo) {
+            await (0, update_checker_1.showUpdateNotification)(updateInfo);
+            return true;
+        }
+    }
+    catch (_e) {
+        // Silently fail
+    }
+    return false;
+}
+function resolveNativeClaudeLaunchArgs(args, profileType, targetConfigDir) {
+    const config = (0, unified_config_loader_1.getOfficialChannelsConfig)();
+    const environment = (0, official_channels_runtime_1.getOfficialChannelsEnvironmentStatus)(targetConfigDir ? { CLAUDE_CONFIG_DIR: targetConfigDir } : undefined);
+    const channelReadiness = {
+        telegram: (0, official_channels_store_1.getOfficialChannelReadiness)('telegram'),
+        discord: (0, official_channels_store_1.getOfficialChannelReadiness)('discord'),
+        imessage: !(0, official_channels_runtime_1.officialChannelRequiresMacOS)('imessage') || process.platform === 'darwin',
+    };
+    const plan = (0, official_channels_runtime_1.resolveOfficialChannelsLaunchPlan)({
+        args,
+        config,
+        target: 'claude',
+        profileType,
+        environment,
+        channelReadiness,
+    });
+    for (const message of plan.skippedMessages) {
+        console.error((0, ui_1.warn)(message));
+    }
+    if (config.selected.length > 0 &&
+        environment.auth.state === 'eligible' &&
+        environment.auth.orgRequirementMessage) {
+        console.error((0, ui_1.warn)(environment.auth.orgRequirementMessage));
+    }
+    if (!plan.applied) {
+        return args;
+    }
+    return (0, official_channels_runtime_1.buildOfficialChannelsArgs)(args, plan.appliedChannels, plan.wantsPermissionBypass);
+}
+function shouldPassthroughNativeCodexFlagCommand(args) {
+    return getNativeCodexPassthroughArgs(args) !== null;
+}
+function getNativeCodexPassthroughArgs(args) {
+    const targetArgs = (0, target_resolver_1.stripTargetFlag)(args);
+    if ((0, target_resolver_1.resolveTargetType)(args) !== 'codex' || targetArgs.length === 0) {
+        return null;
+    }
+    const firstArg = targetArgs[0] || '';
+    if (CODEX_NATIVE_PASSTHROUGH_FLAGS.has(firstArg)) {
+        return targetArgs;
+    }
+    const secondArg = targetArgs[1] || '';
+    if (firstArg === 'codex' && CODEX_NATIVE_PASSTHROUGH_FLAGS.has(secondArg)) {
+        return targetArgs.slice(1);
+    }
+    return null;
+}
+function execNativeCodexFlagCommand(args) {
+    const adapter = (0, targets_1.getTarget)('codex');
+    if (!adapter) {
+        console.error((0, ui_1.fail)('Target adapter not found for "codex"'));
+        process.exit(1);
+    }
+    const binaryInfo = adapter.detectBinary();
+    if (!binaryInfo) {
+        console.error((0, ui_1.fail)('Codex CLI not found.'));
+        console.error((0, ui_1.info)('Install a recent @openai/codex build, then retry.'));
+        process.exit(1);
+    }
+    const targetArgs = getNativeCodexPassthroughArgs(args);
+    if (!targetArgs) {
+        console.error((0, ui_1.fail)('Native Codex passthrough args could not be resolved.'));
+        process.exit(1);
+    }
+    const creds = {
+        profile: 'default',
+        baseUrl: '',
+        apiKey: '',
+    };
+    const builtArgs = adapter.buildArgs('default', targetArgs, {
+        creds,
+        profileType: 'default',
+        binaryInfo,
+    });
+    const targetEnv = adapter.buildEnv(creds, 'default');
+    adapter.exec(builtArgs, targetEnv, { binaryInfo });
+}
+async function main() {
+    // Register target adapters
+    (0, targets_1.registerTarget)(new targets_1.ClaudeAdapter());
+    (0, targets_1.registerTarget)(new targets_1.DroidAdapter());
+    (0, targets_1.registerTarget)(new targets_1.CodexAdapter());
+    const args = process.argv.slice(2);
+    const isCompletionCommand = args[0] === '__complete';
+    // Initialize UI colors early to ensure consistent colored output
+    // Must happen before any status messages (ok, info, fail, etc.)
+    if (!isCompletionCommand && process.stdout.isTTY && !process.env['CI']) {
+        const { initUI } = await Promise.resolve().then(() => __importStar(require('./utils/ui')));
+        await initUI();
+    }
+    // Parse --config-dir flag (must happen before any config loading)
+    const configDirIdx = args.findIndex((a) => a === '--config-dir' || a.startsWith('--config-dir='));
+    if (configDirIdx !== -1) {
+        const arg = args[configDirIdx];
+        let configDirValue;
+        let spliceCount = 1;
+        if (arg.startsWith('--config-dir=')) {
+            configDirValue = arg.split('=').slice(1).join('=');
+        }
+        else {
+            configDirValue = args[configDirIdx + 1];
+            spliceCount = 2;
+        }
+        if (!configDirValue || configDirValue.startsWith('-')) {
+            console.error((0, ui_1.fail)('--config-dir requires a path argument'));
+            process.exit(1);
+        }
+        try {
+            const stat = fs.statSync(configDirValue);
+            if (!stat.isDirectory()) {
+                console.error((0, ui_1.fail)(`Not a directory: ${configDirValue}`));
+                process.exit(1);
+            }
+        }
+        catch {
+            console.error((0, ui_1.fail)(`Config directory not found: ${configDirValue}`));
+            console.error((0, ui_1.info)('Create the directory first, then copy your config files into it.'));
+            process.exit(1);
+        }
+        (0, config_manager_1.setGlobalConfigDir)(configDirValue);
+        // Security warning: cloud sync paths expose OAuth tokens
+        const cloudService = (0, config_manager_1.detectCloudSyncPath)(configDirValue);
+        if (!isCompletionCommand && cloudService) {
+            console.error((0, ui_1.warn)(`CCS directory is under ${cloudService}.`));
+            console.error('    OAuth tokens in cliproxy/auth/ will be synced to cloud.');
+            console.error('    Consider: CCS_DIR=/path/outside/cloud ccs ...');
+        }
+        // Remove consumed args so they don't leak to Claude CLI
+        args.splice(configDirIdx, spliceCount);
+    }
+    else if (process.env.CCS_DIR) {
+        // Also warn for CCS_DIR env var pointing to cloud sync
+        const cloudService = (0, config_manager_1.detectCloudSyncPath)(process.env.CCS_DIR);
+        if (!isCompletionCommand && cloudService) {
+            console.error((0, ui_1.warn)(`CCS directory is under ${cloudService}.`));
+            console.error('    OAuth tokens in cliproxy/auth/ will be synced to cloud.');
+            console.error('    Consider: CCS_DIR=/path/outside/cloud ccs ...');
+        }
+    }
+    else if (process.env.CCS_HOME) {
+        // Also warn for CCS_HOME env var pointing to cloud sync
+        const cloudService = (0, config_manager_1.detectCloudSyncPath)(process.env.CCS_HOME);
+        if (!isCompletionCommand && cloudService) {
+            console.error((0, ui_1.warn)(`CCS directory is under ${cloudService}.`));
+            console.error('    OAuth tokens in cliproxy/auth/ will be synced to cloud.');
+            console.error('    Consider: CCS_DIR=/path/outside/cloud ccs ...');
+        }
+    }
+    if (isCompletionCommand) {
+        await (0, root_command_router_1.tryHandleRootCommand)(args);
+        return;
+    }
+    if (shouldPassthroughNativeCodexFlagCommand(args)) {
+        execNativeCodexFlagCommand(args);
+        return;
+    }
+    const firstArg = args[0];
+    // Trigger update check early for ALL commands except version/help/update
+    // Only if TTY and not CI to avoid noise in automated environments
+    const skipUpdateCheck = [
+        'version',
+        '--version',
+        '-v',
+        'help',
+        '--help',
+        '-h',
+        'update',
+        '--update',
+    ];
+    if (process.stdout.isTTY && !process.env['CI'] && !skipUpdateCheck.includes(firstArg)) {
+        // 1. Show cached update notification (async for proper UI)
+        await showCachedUpdateNotification();
+        // 2. Refresh cache in background if stale (non-blocking)
+        if ((0, update_checker_1.isCacheStale)()) {
+            refreshUpdateCache();
+        }
+    }
+    // Auto-migrate to unified config format (silent if already migrated)
+    // Skip if user is explicitly running migrate command
+    if (firstArg !== 'migrate') {
+        const { autoMigrate } = await Promise.resolve().then(() => __importStar(require('./config/migration-manager')));
+        await autoMigrate();
+    }
+    // Auto-recovery for missing configuration (BEFORE any early-exit commands)
+    // This ensures ALL commands benefit from auto-recovery, not just profile-switching flow
+    // Recovery is safe to run early - it only creates missing files with safe defaults
+    // Wrapped in try-catch to prevent blocking --version/--help on permission errors
+    try {
+        const RecoveryManagerModule = await Promise.resolve().then(() => __importStar(require('./management/recovery-manager')));
+        const RecoveryManager = RecoveryManagerModule.default;
+        const recovery = new RecoveryManager();
+        const recovered = recovery.recoverAll();
+        if (recovered) {
+            recovery.showRecoveryHints();
+        }
+    }
+    catch (err) {
+        // Recovery is best-effort - don't block basic CLI functionality
+        console.warn('[!] Recovery failed:', err.message);
+    }
+    if (await (0, root_command_router_1.tryHandleRootCommand)(args)) {
+        return;
+    }
+    // Special case: copilot command (GitHub Copilot integration)
+    // Route known subcommands to command handler, keep all other args as profile passthrough.
+    if (firstArg === 'copilot' && args.length > 1) {
+        const copilotToken = args[1];
+        const shouldRouteToCopilotCommand = (0, constants_1.isCopilotSubcommandToken)(copilotToken);
+        if (shouldRouteToCopilotCommand) {
+            const { handleCopilotCommand } = await Promise.resolve().then(() => __importStar(require('./commands/copilot-command')));
+            const exitCode = await handleCopilotCommand(args.slice(1));
+            process.exit(exitCode);
+        }
+    }
+    // Special case: cursor command (Cursor local proxy integration)
+    // Route known admin subcommands to the command handler, keep all other args as profile passthrough.
+    if (firstArg === 'cursor' && args.length > 1) {
+        const { handleCursorCommand } = await Promise.resolve().then(() => __importStar(require('./commands/cursor-command')));
+        const cursorToken = args[1];
+        if ((0, constants_2.isCursorSubcommandToken)(cursorToken)) {
+            const exitCode = await handleCursorCommand(args.slice(1));
+            process.exit(exitCode);
+        }
+    }
+    // First-time install: offer setup wizard for interactive users
+    // Check independently of recovery status (user may have empty config.yaml)
+    // Skip if headless, CI, or non-TTY environment
+    const { isFirstTimeInstall } = await Promise.resolve().then(() => __importStar(require('./commands/setup-command')));
+    if (process.stdout.isTTY && !process.env['CI'] && isFirstTimeInstall()) {
+        console.log('');
+        console.log((0, ui_1.info)('First-time install detected. Run `ccs setup` for guided configuration.'));
+        console.log('    Or use `ccs config` for the web dashboard.');
+        console.log('');
+    }
+    // Use ProfileDetector to determine profile type
+    const ProfileDetectorModule = await Promise.resolve().then(() => __importStar(require('./auth/profile-detector')));
+    const ProfileDetector = ProfileDetectorModule.default;
+    const InstanceManagerModule = await Promise.resolve().then(() => __importStar(require('./management/instance-manager')));
+    const InstanceManager = InstanceManagerModule.default;
+    const ProfileRegistryModule = await Promise.resolve().then(() => __importStar(require('./auth/profile-registry')));
+    const ProfileRegistry = ProfileRegistryModule.default;
+    const AccountContextModule = await Promise.resolve().then(() => __importStar(require('./auth/account-context')));
+    const { resolveAccountContextPolicy, isAccountContextMetadata } = AccountContextModule;
+    const ProfileContinuityModule = await Promise.resolve().then(() => __importStar(require('./auth/profile-continuity-inheritance')));
+    const { resolveProfileContinuityInheritance } = ProfileContinuityModule;
+    const detector = new ProfileDetector();
+    try {
+        // Detect profile (strip --target flags before profile detection)
+        const cleanArgs = (0, target_resolver_1.stripTargetFlag)(args);
+        const { profile, remainingArgs } = detectProfile(cleanArgs);
+        const profileInfo = detector.detectProfileType(profile);
+        let resolvedTarget;
+        try {
+            resolvedTarget = (0, target_resolver_1.resolveTargetType)(args, profileInfo.target ? { target: profileInfo.target } : undefined);
+        }
+        catch (error) {
+            console.error((0, ui_1.fail)(error.message));
+            process.exit(1);
+            return;
+        }
+        // Detect Claude CLI (needed for claude target and all CLIProxy-derived flows)
+        const claudeCliRaw = (0, claude_detector_1.detectClaudeCli)();
+        if (resolvedTarget === 'claude' && !claudeCliRaw) {
+            await error_manager_1.ErrorManager.showClaudeNotFound();
+            process.exit(1);
+        }
+        const claudeCli = claudeCliRaw || '';
+        // Resolve non-claude target adapter once.
+        const targetAdapter = resolvedTarget !== 'claude' ? (0, targets_1.getTarget)(resolvedTarget) : null;
+        let resolvedSettingsPath;
+        let resolvedSettings;
+        let resolvedCliproxyBridge;
+        // Preflight unsupported profile/target combinations BEFORE binary detection,
+        // so users get the most actionable error even when the target CLI is not installed.
+        if (resolvedTarget !== 'claude') {
+            if (!targetAdapter) {
+                console.error((0, ui_1.fail)(`Target adapter not found for "${resolvedTarget}"`));
+                process.exit(1);
+            }
+            if (profileInfo.type === 'settings') {
+                resolvedSettingsPath = profileInfo.settingsPath
+                    ? (0, helpers_1.expandPath)(profileInfo.settingsPath)
+                    : (0, config_manager_1.getSettingsPath)(profileInfo.name);
+                resolvedSettings = (0, config_manager_1.loadSettings)(resolvedSettingsPath);
+                resolvedCliproxyBridge = (0, cliproxy_profile_bridge_1.resolveCliproxyBridgeMetadata)(resolvedSettings);
+                const compatibility = (0, targets_1.evaluateTargetRuntimeCompatibility)({
+                    target: resolvedTarget,
+                    profileType: profileInfo.type,
+                    cliproxyBridgeProvider: resolvedCliproxyBridge?.provider ?? null,
+                });
+                if (!compatibility.supported) {
+                    console.error((0, ui_1.fail)(compatibility.reason || `${targetAdapter.displayName} does not support this profile.`));
+                    if (compatibility.suggestion) {
+                        console.error((0, ui_1.info)(compatibility.suggestion));
+                    }
+                    process.exit(1);
+                }
+            }
+            else {
+                const compatibility = (0, targets_1.evaluateTargetRuntimeCompatibility)({
+                    target: resolvedTarget,
+                    profileType: profileInfo.type,
+                    cliproxyProvider: profileInfo.type === 'cliproxy' ? profileInfo.provider : undefined,
+                    isComposite: profileInfo.type === 'cliproxy' ? Boolean(profileInfo.isComposite) : undefined,
+                });
+                if (!compatibility.supported) {
+                    console.error((0, ui_1.fail)(compatibility.reason || `${targetAdapter.displayName} does not support this profile.`));
+                    if (compatibility.suggestion) {
+                        console.error((0, ui_1.info)(compatibility.suggestion));
+                    }
+                    process.exit(1);
+                }
+            }
+            if (profileInfo.type === 'default') {
+                if (!targetAdapter.supportsProfileType('default')) {
+                    console.error((0, ui_1.fail)(`${targetAdapter.displayName} does not support default profile mode`));
+                    process.exit(1);
+                }
+                // For default mode, Droid requires explicit credentials from environment.
+                if (resolvedTarget === 'droid') {
+                    const baseUrl = process.env['ANTHROPIC_BASE_URL'] || '';
+                    const apiKey = process.env['ANTHROPIC_AUTH_TOKEN'] || '';
+                    if (!baseUrl.trim() || !apiKey.trim()) {
+                        console.error((0, ui_1.fail)(`${targetAdapter.displayName} default mode requires ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN`));
+                        console.error((0, ui_1.info)('Use a settings-based profile instead: ccs glm --target droid'));
+                        process.exit(1);
+                    }
+                }
+            }
+        }
+        // For non-claude targets, verify target binary exists once and pass it through.
+        const targetBinaryInfo = targetAdapter?.detectBinary() ?? null;
+        if (resolvedTarget !== 'claude' && !targetBinaryInfo) {
+            const displayName = targetAdapter?.displayName || resolvedTarget;
+            console.error((0, ui_1.fail)(`${displayName} CLI not found.`));
+            if (resolvedTarget === 'droid') {
+                console.error((0, ui_1.info)('Install: npm i -g @factory/cli'));
+            }
+            else if (resolvedTarget === 'codex') {
+                console.error((0, ui_1.info)('Install a recent @openai/codex build, then retry.'));
+            }
+            process.exit(1);
+        }
+        // Best-effort: prune stale Droid model entries at runtime so settings.json stays clean.
+        if (resolvedTarget === 'droid') {
+            try {
+                const allProfiles = detector.getAllProfiles();
+                const activeProfiles = allProfiles.settings.filter((name) => /^[a-zA-Z0-9._-]+$/.test(name));
+                await (0, targets_1.pruneOrphanedModels)(activeProfiles);
+            }
+            catch (error) {
+                console.error((0, ui_1.warn)(`[!] Droid prune skipped: ${error.message}`));
+            }
+        }
+        let targetRemainingArgs = remainingArgs;
+        let runtimeReasoningOverride;
+        if (resolvedTarget === 'droid') {
+            try {
+                const droidRoute = (0, droid_command_router_1.routeDroidCommandArgs)(remainingArgs);
+                targetRemainingArgs = droidRoute.argsForDroid;
+                if (droidRoute.mode === 'interactive') {
+                    const runtime = resolveRuntimeReasoningFlags(remainingArgs, process.env.CCS_THINKING);
+                    targetRemainingArgs = runtime.argsWithoutReasoningFlags;
+                    runtimeReasoningOverride = runtime.reasoningOverride;
+                }
+                else {
+                    if (droidRoute.duplicateReasoningDisplays.length > 0) {
+                        console.error((0, ui_1.warn)(`[!] Multiple reasoning flags detected. Using first occurrence: ${droidRoute.reasoningSourceDisplay || '<first-flag>'}`));
+                    }
+                    if (droidRoute.autoPrependedExec && process.stdout.isTTY) {
+                        console.error((0, ui_1.info)('Detected Droid exec-only flags. Routing as: droid exec <flags> [prompt]'));
+                    }
+                }
+            }
+            catch (error) {
+                if (error instanceof droid_reasoning_runtime_1.DroidReasoningFlagError || error instanceof droid_command_router_1.DroidCommandRouterError) {
+                    exitWithRuntimeReasoningFlagError(error.message, {
+                        codexAliasLevels: 'minimal|low|medium|high|xhigh',
+                        includeDroidExecExample: true,
+                    });
+                }
+                throw error;
+            }
+        }
+        else if (resolvedTarget === 'codex') {
+            try {
+                const runtime = resolveRuntimeReasoningFlags(remainingArgs, process.env.CCS_THINKING);
+                targetRemainingArgs = runtime.argsWithoutReasoningFlags;
+                const normalizedReasoning = normalizeCodexRuntimeReasoningOverride(runtime.reasoningOverride);
+                if (runtime.reasoningOverride !== undefined && !normalizedReasoning) {
+                    if (runtime.reasoningSource === 'flag') {
+                        throw new droid_reasoning_runtime_1.DroidReasoningFlagError('Codex target supports reasoning levels only: minimal, low, medium, high, xhigh.', '--effort');
+                    }
+                    runtimeReasoningOverride = undefined;
+                }
+                else {
+                    runtimeReasoningOverride = normalizedReasoning;
+                }
+            }
+            catch (error) {
+                if (error instanceof droid_reasoning_runtime_1.DroidReasoningFlagError) {
+                    exitWithRuntimeReasoningFlagError(error.message, {
+                        codexAliasLevels: 'minimal|low|medium|high|xhigh',
+                    });
+                }
+                throw error;
+            }
+        }
+        // Special case: headless delegation (-p/--prompt)
+        // Keep existing behavior for Claude targets only; non-claude targets must continue
+        // through normal adapter dispatch logic.
+        if (args.includes('-p') || args.includes('--prompt')) {
+            const shouldUseDelegation = resolvedTarget === 'claude' && profileInfo.type !== 'cliproxy';
+            if (shouldUseDelegation) {
+                const { DelegationHandler } = await Promise.resolve().then(() => __importStar(require('./delegation/delegation-handler')));
+                const handler = new DelegationHandler();
+                await handler.route(cleanArgs);
+                return;
+            }
+        }
+        if (profileInfo.type === 'cliproxy') {
+            // CLIPROXY FLOW: OAuth-based profiles (gemini, codex, agy, qwen) or user-defined variants
+            if (resolvedTarget === 'claude') {
+                (0, websearch_manager_1.ensureWebSearchMcpOrThrow)();
+                (0, image_analysis_1.ensureImageAnalysisMcpOrThrow)();
+            }
+            const imageAnalysisFallbackHookReady = resolvedTarget === 'claude' ? (0, hooks_1.prepareImageAnalysisFallbackHook)() : false;
+            const provider = profileInfo.provider || profileInfo.name;
+            // Inject Image Analyzer hook into profile settings before launch
+            (0, image_analyzer_profile_hook_injector_1.ensureProfileHooks)({
+                profileName: profileInfo.name,
+                profileType: profileInfo.type,
+                cliproxyProvider: provider,
+                isComposite: profileInfo.isComposite,
+                settingsPath: profileInfo.settingsPath ? (0, helpers_1.expandPath)(profileInfo.settingsPath) : undefined,
+                sharedHookInstalled: imageAnalysisFallbackHookReady,
+            });
+            const customSettingsPath = profileInfo.settingsPath; // undefined for hardcoded profiles
+            const variantPort = profileInfo.port; // variant-specific port for isolation
+            const cliproxyPort = variantPort || port_manager_1.CLIPROXY_DEFAULT_PORT;
+            if (resolvedTarget !== 'claude') {
+                const adapter = targetAdapter;
+                if (!adapter) {
+                    console.error((0, ui_1.fail)(`Target adapter not found for "${resolvedTarget}"`));
+                    process.exitCode = 1;
+                    return;
+                }
+                if (!adapter.supportsProfileType('cliproxy')) {
+                    console.error((0, ui_1.fail)(`${adapter.displayName} does not support CLIProxy profiles`));
+                    process.exitCode = 1;
+                    return;
+                }
+                // Keep CLIProxy management/auth flags on Claude flow only.
+                const unsupportedCliproxyFlags = [
+                    '--auth',
+                    '--logout',
+                    '--accounts',
+                    '--add',
+                    '--use',
+                    '--config',
+                    '--headless',
+                    '--paste-callback',
+                    '--port-forward',
+                    '--nickname',
+                    '--kiro-auth-method',
+                    '--backend',
+                    '--proxy-host',
+                    '--proxy-port',
+                    '--proxy-protocol',
+                    '--proxy-auth-token',
+                    '--proxy-timeout',
+                    '--local-proxy',
+                    '--remote-only',
+                    '--no-fallback',
+                    '--allow-self-signed',
+                    '--1m',
+                    '--no-1m',
+                ];
+                const providedUnsupportedFlag = unsupportedCliproxyFlags.find((flag) => targetRemainingArgs.includes(flag) ||
+                    targetRemainingArgs.some((arg) => arg.startsWith(`${flag}=`)));
+                if (providedUnsupportedFlag) {
+                    console.error((0, ui_1.fail)(`${providedUnsupportedFlag} is only supported when running CLIProxy profiles on Claude target`));
+                    console.error((0, ui_1.info)(`Run with Claude target: ccs ${profileInfo.name} --target claude ...`));
+                    process.exitCode = 1;
+                    return;
+                }
+                // For Droid execution path, require existing OAuth auth and running local proxy.
+                if (profileInfo.isComposite && profileInfo.compositeTiers) {
+                    const compositeProviders = [
+                        ...new Set(Object.values(profileInfo.compositeTiers).map((tier) => tier.provider)),
+                    ];
+                    const missingProvider = compositeProviders.find((p) => !(0, cliproxy_1.isAuthenticated)(p));
+                    if (missingProvider) {
+                        console.error((0, ui_1.fail)(`Missing OAuth auth for composite tier provider: ${missingProvider}`));
+                        console.error((0, ui_1.info)(`Authenticate first: ccs ${missingProvider} --auth`));
+                        process.exitCode = 1;
+                        return;
+                    }
+                }
+                else if (!(0, cliproxy_1.isAuthenticated)(provider)) {
+                    console.error((0, ui_1.fail)(`No OAuth authentication found for provider: ${provider}`));
+                    console.error((0, ui_1.info)(`Authenticate first: ccs ${provider} --auth`));
+                    process.exitCode = 1;
+                    return;
+                }
+                const ensureServiceResult = await (0, cliproxy_1.ensureCliproxyService)(cliproxyPort, targetRemainingArgs.includes('--verbose') || targetRemainingArgs.includes('-v'));
+                if (!ensureServiceResult.started) {
+                    console.error((0, ui_1.fail)(ensureServiceResult.error || 'Failed to start local CLIProxy service'));
+                    process.exitCode = 1;
+                    return;
+                }
+                const envVars = profileInfo.isComposite && profileInfo.compositeTiers && profileInfo.compositeDefaultTier
+                    ? (0, env_builder_1.getCompositeEnvVars)(profileInfo.compositeTiers, profileInfo.compositeDefaultTier, cliproxyPort, customSettingsPath)
+                    : (0, env_builder_1.getEffectiveEnvVars)(provider, cliproxyPort, customSettingsPath);
+                const creds = {
+                    profile: profileInfo.name,
+                    baseUrl: envVars['ANTHROPIC_BASE_URL'] || '',
+                    apiKey: envVars['ANTHROPIC_AUTH_TOKEN'] || '',
+                    model: envVars['ANTHROPIC_MODEL'] || undefined,
+                    provider: (0, targets_1.resolveDroidProvider)({
+                        provider: envVars['CCS_DROID_PROVIDER'] || envVars['DROID_PROVIDER'],
+                        baseUrl: envVars['ANTHROPIC_BASE_URL'],
+                        model: envVars['ANTHROPIC_MODEL'],
+                    }),
+                    reasoningOverride: runtimeReasoningOverride,
+                    envVars,
+                };
+                if (!creds.baseUrl || !creds.apiKey) {
+                    console.error((0, ui_1.fail)(`Missing CLIProxy runtime credentials for ${profileInfo.name} (ANTHROPIC_BASE_URL/AUTH_TOKEN)`));
+                    console.error((0, ui_1.info)('Reconfigure with: ccs config > CLIProxy, or run ccs <provider> --config'));
+                    process.exitCode = 1;
+                    return;
+                }
+                await adapter.prepareCredentials(creds);
+                const targetArgs = adapter.buildArgs(profileInfo.name, targetRemainingArgs, {
+                    creds,
+                    profileType: profileInfo.type,
+                    binaryInfo: targetBinaryInfo || undefined,
+                });
+                const targetEnv = adapter.buildEnv(creds, profileInfo.type);
+                adapter.exec(targetArgs, targetEnv, { binaryInfo: targetBinaryInfo || undefined });
+                return;
+            }
+            await (0, cliproxy_1.execClaudeWithCLIProxy)(claudeCli, provider, remainingArgs, {
+                customSettingsPath,
+                port: cliproxyPort,
+                isComposite: profileInfo.isComposite,
+                compositeTiers: profileInfo.compositeTiers,
+                compositeDefaultTier: profileInfo.compositeDefaultTier,
+                profileName: profileInfo.name,
+            });
+        }
+        else if (profileInfo.type === 'copilot') {
+            // COPILOT FLOW: GitHub Copilot subscription via copilot-api proxy
+            (0, websearch_manager_1.ensureWebSearchMcpOrThrow)();
+            (0, image_analysis_1.ensureImageAnalysisMcpOrThrow)();
+            const imageAnalysisFallbackHookReady = resolvedTarget === 'claude' ? (0, hooks_1.prepareImageAnalysisFallbackHook)() : false;
+            // Inject Image Analyzer hook into profile settings before launch
+            (0, image_analyzer_profile_hook_injector_1.ensureProfileHooks)({
+                profileName: profileInfo.name,
+                profileType: profileInfo.type,
+                sharedHookInstalled: imageAnalysisFallbackHookReady,
+            });
+            const { executeCopilotProfile } = await Promise.resolve().then(() => __importStar(require('./copilot')));
+            const copilotConfig = profileInfo.copilotConfig;
+            if (!copilotConfig) {
+                console.error((0, ui_1.fail)('Copilot configuration not found'));
+                process.exit(1);
+            }
+            const continuityInheritance = await resolveProfileContinuityInheritance({
+                profileName: profileInfo.name,
+                profileType: profileInfo.type,
+                target: resolvedTarget,
+            });
+            if (continuityInheritance.sourceAccount && process.env.CCS_DEBUG) {
+                console.error((0, ui_1.info)(`Continuity inheritance active: profile "${profileInfo.name}" -> account "${continuityInheritance.sourceAccount}"`));
+            }
+            const exitCode = await executeCopilotProfile(copilotConfig, remainingArgs, continuityInheritance.claudeConfigDir, claudeCli);
+            process.exit(exitCode);
+        }
+        else if (profileInfo.type === 'cursor') {
+            // CURSOR FLOW: local Cursor daemon profile
+            (0, websearch_manager_1.ensureWebSearchMcpOrThrow)();
+            (0, hooks_1.installImageAnalyzerHook)();
+            (0, image_analyzer_profile_hook_injector_1.ensureProfileHooks)({
+                profileName: profileInfo.name,
+                profileType: profileInfo.type,
+            });
+            const { executeCursorProfile } = await Promise.resolve().then(() => __importStar(require('./cursor')));
+            const cursorConfig = profileInfo.cursorConfig;
+            if (!cursorConfig) {
+                console.error((0, ui_1.fail)('Cursor configuration not found'));
+                process.exit(1);
+            }
+            const continuityInheritance = await resolveProfileContinuityInheritance({
+                profileName: profileInfo.name,
+                profileType: profileInfo.type,
+                target: resolvedTarget,
+            });
+            if (continuityInheritance.sourceAccount && process.env.CCS_DEBUG) {
+                console.error((0, ui_1.info)(`Continuity inheritance active: profile "${profileInfo.name}" -> account "${continuityInheritance.sourceAccount}"`));
+            }
+            const exitCode = await executeCursorProfile(cursorConfig, remainingArgs, continuityInheritance.claudeConfigDir, claudeCli);
+            process.exit(exitCode);
+        }
+        else if (profileInfo.type === 'settings') {
+            // Settings-based profiles (glm, glmt) are third-party providers
+            const imageAnalysisMcpReady = resolvedTarget === 'claude' ? (0, image_analysis_1.ensureImageAnalysisMcpOrThrow)() : true;
+            if (resolvedTarget === 'claude') {
+                (0, websearch_manager_1.ensureWebSearchMcpOrThrow)();
+            }
+            // Display WebSearch status (single line, equilibrium UX)
+            (0, websearch_manager_1.displayWebSearchStatus)();
+            const continuityInheritance = resolvedTarget === 'claude'
+                ? await resolveProfileContinuityInheritance({
+                    profileName: profileInfo.name,
+                    profileType: profileInfo.type,
+                    target: resolvedTarget,
+                })
+                : {};
+            if (continuityInheritance.sourceAccount && process.env.CCS_DEBUG) {
+                console.error((0, ui_1.info)(`Continuity inheritance active: profile "${profileInfo.name}" -> account "${continuityInheritance.sourceAccount}"`));
+            }
+            const inheritedClaudeConfigDir = continuityInheritance.claudeConfigDir;
+            (0, websearch_manager_1.syncWebSearchMcpToConfigDir)(inheritedClaudeConfigDir);
+            (0, image_analysis_1.syncImageAnalysisMcpToConfigDir)(inheritedClaudeConfigDir);
+            const imageAnalysisFallbackHookReady = resolvedTarget === 'claude' ? (0, hooks_1.prepareImageAnalysisFallbackHook)() : false;
+            const expandedSettingsPath = resolvedSettingsPath ??
+                (profileInfo.settingsPath
+                    ? (0, helpers_1.expandPath)(profileInfo.settingsPath)
+                    : (0, config_manager_1.getSettingsPath)(profileInfo.name));
+            const settings = resolvedSettings ?? (0, config_manager_1.loadSettings)(expandedSettingsPath);
+            const cliproxyBridge = resolvedCliproxyBridge ?? (0, cliproxy_profile_bridge_1.resolveCliproxyBridgeMetadata)(settings);
+            (0, image_analyzer_profile_hook_injector_1.ensureProfileHooks)({
+                profileName: profileInfo.name,
+                profileType: profileInfo.type,
+                settingsPath: expandedSettingsPath,
+                settings,
+                cliproxyBridge,
+                sharedHookInstalled: imageAnalysisFallbackHookReady,
+            });
+            if (resolvedTarget !== 'claude') {
+                const compatibility = (0, targets_1.evaluateTargetRuntimeCompatibility)({
+                    target: resolvedTarget,
+                    profileType: profileInfo.type,
+                    cliproxyBridgeProvider: cliproxyBridge?.provider ?? null,
+                });
+                if (!compatibility.supported) {
+                    console.error((0, ui_1.fail)(compatibility.reason ||
+                        `${targetAdapter?.displayName || resolvedTarget} does not support this profile.`));
+                    if (compatibility.suggestion) {
+                        console.error((0, ui_1.info)(compatibility.suggestion));
+                    }
+                    process.exit(1);
+                }
+            }
+            const rawSettingsEnv = profileInfo.env ?? settings.env ?? {};
+            const isDeprecatedGlmtProfile = (0, glmt_deprecation_1.isDeprecatedGlmtProfileName)(profileInfo.name);
+            const glmtNormalization = isDeprecatedGlmtProfile
+                ? (0, glmt_deprecation_1.normalizeDeprecatedGlmtEnv)(rawSettingsEnv)
+                : null;
+            const settingsEnv = glmtNormalization?.env ?? rawSettingsEnv;
+            if (glmtNormalization) {
+                for (const message of glmtNormalization.warnings) {
+                    console.error((0, ui_1.warn)(message));
+                }
+            }
+            // Pre-flight validation for Z.AI-compatible profiles.
+            if (profileInfo.name === 'glm' || isDeprecatedGlmtProfile) {
+                const apiKey = settingsEnv['ANTHROPIC_AUTH_TOKEN'];
+                if (apiKey) {
+                    const validation = await (0, api_key_validator_1.validateGlmKey)(apiKey, settingsEnv['ANTHROPIC_BASE_URL']);
+                    if (!validation.valid) {
+                        console.error('');
+                        console.error((0, ui_1.fail)(validation.error || 'API key validation failed'));
+                        if (validation.suggestion) {
+                            console.error('');
+                            console.error(validation.suggestion);
+                        }
+                        console.error('');
+                        console.error((0, ui_1.info)('To skip validation: CCS_SKIP_PREFLIGHT=1 ccs glm "prompt"'));
+                        process.exit(1);
+                    }
+                }
+            }
+            if (profileInfo.name === 'mm') {
+                const apiKey = settingsEnv['ANTHROPIC_AUTH_TOKEN'];
+                if (apiKey) {
+                    const validation = await (0, api_key_validator_1.validateMiniMaxKey)(apiKey, settingsEnv['ANTHROPIC_BASE_URL']);
+                    if (!validation.valid) {
+                        console.error('');
+                        console.error((0, ui_1.fail)(validation.error || 'API key validation failed'));
+                        if (validation.suggestion) {
+                            console.error('');
+                            console.error(validation.suggestion);
+                        }
+                        console.error('');
+                        console.error((0, ui_1.info)('To skip validation: CCS_SKIP_PREFLIGHT=1 ccs mm "prompt"'));
+                        process.exit(1);
+                    }
+                }
+            }
+            // Pre-flight validation for Anthropic direct profiles (ANTHROPIC_API_KEY + no BASE_URL)
+            {
+                const anthropicApiKey = settingsEnv['ANTHROPIC_API_KEY'];
+                const hasBaseUrl = !!settingsEnv['ANTHROPIC_BASE_URL'];
+                if (anthropicApiKey && !hasBaseUrl) {
+                    const validation = await (0, api_key_validator_1.validateAnthropicKey)(anthropicApiKey);
+                    if (!validation.valid) {
+                        console.error('');
+                        console.error((0, ui_1.fail)(validation.error || 'API key validation failed'));
+                        if (validation.suggestion) {
+                            console.error('');
+                            console.error(validation.suggestion);
+                        }
+                        console.error('');
+                        console.error((0, ui_1.info)(`To skip validation: CCS_SKIP_PREFLIGHT=1 ccs ${profileInfo.name} "prompt"`));
+                        process.exit(1);
+                    }
+                }
+            }
+            const webSearchEnv = (0, websearch_manager_1.getWebSearchHookEnv)();
+            const imageAnalysisStatus = await (0, hooks_1.resolveImageAnalysisRuntimeStatus)({
+                profileName: profileInfo.name,
+                profileType: profileInfo.type,
+                settings,
+                cliproxyBridge,
+                sharedHookInstalled: imageAnalysisFallbackHookReady,
+            });
+            const runtimeConnection = (0, hooks_1.resolveImageAnalysisRuntimeConnection)();
+            let imageAnalysisEnv = (0, hooks_1.getImageAnalysisHookEnv)({
+                profileName: profileInfo.name,
+                profileType: profileInfo.type,
+                settings,
+                cliproxyBridge,
+            });
+            imageAnalysisEnv = (0, hooks_1.applyImageAnalysisRuntimeOverrides)(imageAnalysisEnv, {
+                backendId: imageAnalysisStatus.backendId,
+                model: imageAnalysisStatus.model,
+                runtimePath: imageAnalysisStatus.runtimePath,
+                baseUrl: runtimeConnection.baseUrl,
+                apiKey: runtimeConnection.apiKey,
+                allowSelfSigned: runtimeConnection.allowSelfSigned,
+            });
+            if (!imageAnalysisMcpReady) {
+                imageAnalysisEnv = {
+                    ...imageAnalysisEnv,
+                    CCS_CURRENT_PROVIDER: '',
+                    CCS_IMAGE_ANALYSIS_SKIP: '1',
+                };
+            }
+            const imageAnalysisProvider = imageAnalysisEnv['CCS_CURRENT_PROVIDER'];
+            if (resolvedTarget === 'claude' &&
+                imageAnalysisEnv['CCS_IMAGE_ANALYSIS_SKIP'] !== '1' &&
+                imageAnalysisProvider) {
+                const verboseProxyLaunch = remainingArgs.includes('--verbose') ||
+                    remainingArgs.includes('-v') ||
+                    targetRemainingArgs.includes('--verbose') ||
+                    targetRemainingArgs.includes('-v');
+                if (imageAnalysisStatus.effectiveRuntimeMode === 'native-read') {
+                    console.error((0, ui_1.info)(`${imageAnalysisStatus.effectiveRuntimeReason || `Image analysis via ${imageAnalysisProvider} is unavailable.`} This session will use native Read.`));
+                    imageAnalysisEnv = {
+                        ...imageAnalysisEnv,
+                        CCS_CURRENT_PROVIDER: '',
+                        CCS_IMAGE_ANALYSIS_SKIP: '1',
+                    };
+                }
+                else if (imageAnalysisStatus.proxyReadiness === 'stopped') {
+                    const ensureServiceResult = await (0, cliproxy_1.ensureCliproxyService)(port_manager_1.CLIPROXY_DEFAULT_PORT, verboseProxyLaunch);
+                    if (!ensureServiceResult.started) {
+                        console.error((0, ui_1.warn)(`Image analysis via ${imageAnalysisProvider} is unavailable because CCS could not start the local CLIProxy service. This session will use native Read.`));
+                        imageAnalysisEnv = {
+                            ...imageAnalysisEnv,
+                            CCS_CURRENT_PROVIDER: '',
+                            CCS_IMAGE_ANALYSIS_SKIP: '1',
+                        };
+                    }
+                }
+            }
+            // Get global env vars (DISABLE_TELEMETRY, etc.) for third-party profiles
+            const globalEnvConfig = (0, unified_config_loader_1.getGlobalEnvConfig)();
+            const globalEnv = globalEnvConfig.enabled ? globalEnvConfig.env : {};
+            // Log global env injection for visibility (debug mode only)
+            if (globalEnvConfig.enabled && Object.keys(globalEnv).length > 0 && process.env.CCS_DEBUG) {
+                const envNames = Object.keys(globalEnv).join(', ');
+                console.error((0, ui_1.info)(`Global env: ${envNames}`));
+            }
+            // Explicitly inject effective settings env vars so stale ANTHROPIC_*
+            // values from prior sessions cannot leak into the active profile.
+            const envVars = {
+                ...globalEnv,
+                ...settingsEnv,
+                ...(inheritedClaudeConfigDir ? { CLAUDE_CONFIG_DIR: inheritedClaudeConfigDir } : {}),
+                ...webSearchEnv,
+                ...imageAnalysisEnv,
+                CCS_PROFILE_TYPE: 'settings',
+            };
+            // Dispatch through target adapter for non-claude targets
+            if (resolvedTarget !== 'claude') {
+                const adapter = targetAdapter;
+                if (!adapter) {
+                    console.error((0, ui_1.fail)(`Target adapter not found for "${resolvedTarget}"`));
+                    process.exit(1);
+                }
+                const directAnthropicBaseUrl = settingsEnv['ANTHROPIC_BASE_URL'] ||
+                    (settingsEnv['ANTHROPIC_API_KEY'] ? 'https://api.anthropic.com' : '');
+                const creds = {
+                    profile: profileInfo.name,
+                    baseUrl: directAnthropicBaseUrl,
+                    apiKey: settingsEnv['ANTHROPIC_AUTH_TOKEN'] || settingsEnv['ANTHROPIC_API_KEY'] || '',
+                    model: settingsEnv['ANTHROPIC_MODEL'],
+                    provider: (0, targets_1.resolveDroidProvider)({
+                        provider: settingsEnv['CCS_DROID_PROVIDER'] || settingsEnv['DROID_PROVIDER'],
+                        baseUrl: directAnthropicBaseUrl,
+                        model: settingsEnv['ANTHROPIC_MODEL'],
+                    }),
+                    reasoningOverride: runtimeReasoningOverride,
+                    envVars,
+                };
+                await adapter.prepareCredentials(creds);
+                const targetArgs = adapter.buildArgs(profileInfo.name, targetRemainingArgs, {
+                    creds,
+                    profileType: profileInfo.type,
+                    binaryInfo: targetBinaryInfo || undefined,
+                });
+                const targetEnv = adapter.buildEnv(creds, profileInfo.type);
+                adapter.exec(targetArgs, targetEnv, { binaryInfo: targetBinaryInfo || undefined });
+                return;
+            }
+            const imageAnalysisArgs = imageAnalysisMcpReady
+                ? (0, image_analysis_1.appendThirdPartyImageAnalysisToolArgs)(remainingArgs)
+                : remainingArgs;
+            const launchArgs = [
+                '--settings',
+                expandedSettingsPath,
+                ...(0, websearch_manager_1.appendThirdPartyWebSearchToolArgs)(imageAnalysisArgs),
+            ];
+            const traceEnv = (0, websearch_manager_1.createWebSearchTraceContext)({
+                launcher: 'ccs.settings-profile',
+                args: launchArgs,
+                profile: profileInfo.name,
+                profileType: profileInfo.type,
+                settingsPath: expandedSettingsPath,
+            });
+            (0, shell_executor_1.execClaude)(claudeCli, launchArgs, { ...envVars, ...traceEnv });
+        }
+        else if (profileInfo.type === 'account') {
+            // NEW FLOW: Account-based profile (work, personal)
+            // All platforms: Use instance isolation with CLAUDE_CONFIG_DIR
+            const registry = new ProfileRegistry();
+            const instanceMgr = new InstanceManager();
+            const accountMetadata = isAccountContextMetadata(profileInfo.profile)
+                ? profileInfo.profile
+                : undefined;
+            const isBareProfile = typeof profileInfo.profile === 'object' &&
+                profileInfo.profile !== null &&
+                profileInfo.profile.bare === true;
+            const contextPolicy = resolveAccountContextPolicy(accountMetadata);
+            // Ensure instance exists (lazy init if needed)
+            const instancePath = await instanceMgr.ensureInstance(profileInfo.name, contextPolicy, {
+                bare: isBareProfile,
+            });
+            // Update last_used timestamp (check unified config first, fallback to legacy)
+            if (registry.hasAccountUnified(profileInfo.name)) {
+                registry.touchAccountUnified(profileInfo.name);
+            }
+            else {
+                registry.touchProfile(profileInfo.name);
+            }
+            // Execute Claude with instance isolation
+            // Skip WebSearch hook - account profiles use native server-side WebSearch
+            // Skip Image Analyzer hook - account profiles have native vision support
+            const envVars = {
+                CLAUDE_CONFIG_DIR: instancePath,
+                CCS_PROFILE_TYPE: 'account',
+                CCS_WEBSEARCH_SKIP: '1',
+                CCS_IMAGE_ANALYSIS_SKIP: '1',
+            };
+            await (0, resume_lane_warning_1.maybeWarnAboutResumeLaneMismatch)(profileInfo.name, instancePath, remainingArgs);
+            const launchArgs = resolveNativeClaudeLaunchArgs(remainingArgs, 'account', instancePath);
+            (0, shell_executor_1.execClaude)(claudeCli, launchArgs, envVars);
+        }
+        else {
+            // DEFAULT: No profile configured, use Claude's own defaults
+            // Skip WebSearch hook - native Claude has server-side WebSearch
+            // Skip Image Analyzer hook - native Claude has native vision support
+            const envVars = {
+                CCS_PROFILE_TYPE: 'default',
+                CCS_WEBSEARCH_SKIP: '1',
+                CCS_IMAGE_ANALYSIS_SKIP: '1',
+            };
+            if (resolvedTarget === 'claude') {
+                const defaultContinuityInheritance = await resolveProfileContinuityInheritance({
+                    profileName: profileInfo.name,
+                    profileType: profileInfo.type,
+                    target: resolvedTarget,
+                });
+                if (defaultContinuityInheritance.sourceAccount && process.env.CCS_DEBUG) {
+                    console.error((0, ui_1.info)(`Continuity inheritance active: profile "${profileInfo.name}" -> account "${defaultContinuityInheritance.sourceAccount}"`));
+                }
+                if (defaultContinuityInheritance.claudeConfigDir) {
+                    envVars.CLAUDE_CONFIG_DIR = defaultContinuityInheritance.claudeConfigDir;
+                }
+            }
+            // Dispatch through target adapter for non-claude targets
+            if (resolvedTarget !== 'claude') {
+                const adapter = targetAdapter;
+                if (!adapter) {
+                    console.error((0, ui_1.fail)(`Target adapter not found for "${resolvedTarget}"`));
+                    process.exit(1);
+                }
+                if (!adapter.supportsProfileType('default')) {
+                    console.error((0, ui_1.fail)(`${adapter.displayName} does not support default profile mode`));
+                    process.exit(1);
+                }
+                const creds = {
+                    profile: 'default',
+                    baseUrl: process.env['ANTHROPIC_BASE_URL'] || '',
+                    apiKey: process.env['ANTHROPIC_AUTH_TOKEN'] || '',
+                    model: process.env['ANTHROPIC_MODEL'],
+                    provider: (0, targets_1.resolveDroidProvider)({
+                        provider: process.env['CCS_DROID_PROVIDER'] || process.env['DROID_PROVIDER'],
+                        baseUrl: process.env['ANTHROPIC_BASE_URL'],
+                        model: process.env['ANTHROPIC_MODEL'],
+                    }),
+                    reasoningOverride: runtimeReasoningOverride,
+                };
+                if (resolvedTarget === 'droid' && (!creds.baseUrl || !creds.apiKey)) {
+                    console.error((0, ui_1.fail)(`${adapter.displayName} default mode requires ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN`));
+                    console.error((0, ui_1.info)('Use a settings-based profile instead: ccs glm --target droid'));
+                    process.exit(1);
+                }
+                await adapter.prepareCredentials(creds);
+                const targetArgs = adapter.buildArgs('default', targetRemainingArgs, {
+                    creds,
+                    profileType: 'default',
+                    binaryInfo: targetBinaryInfo || undefined,
+                });
+                const targetEnv = adapter.buildEnv(creds, 'default');
+                adapter.exec(targetArgs, targetEnv, { binaryInfo: targetBinaryInfo || undefined });
+                return;
+            }
+            const launchArgs = resolveNativeClaudeLaunchArgs(remainingArgs, 'default', envVars.CLAUDE_CONFIG_DIR);
+            (0, shell_executor_1.execClaude)(claudeCli, launchArgs, envVars);
+        }
+    }
+    catch (error) {
+        const err = error;
+        // Check if this is a profile not found error with suggestions
+        if (err.profileName && err.availableProfiles !== undefined) {
+            const allProfiles = err.availableProfiles.split('\n');
+            await error_manager_1.ErrorManager.showProfileNotFound(err.profileName, allProfiles, err.suggestions);
+        }
+        else {
+            console.error((0, ui_1.fail)(err.message));
+        }
+        process.exit(1);
+    }
+}
+// ========== Global Error Handlers ==========
+// Handle uncaught exceptions
+process.on('uncaughtException', (error) => {
+    (0, errors_1.handleError)(error);
+});
+// Handle unhandled promise rejections
+process.on('unhandledRejection', (reason) => {
+    (0, errors_1.handleError)(reason);
+});
+// Handle process termination signals for cleanup
+process.on('SIGTERM', () => {
+    try {
+        (0, errors_1.runCleanup)();
+    }
+    catch {
+        // Cleanup failure should not block termination.
+    }
+    // If a target exec path registered additional signal listeners, let those
+    // listeners forward/coordinate child shutdown and final exit codes.
+    if (process.listenerCount('SIGTERM') <= 1) {
+        process.exit(143); // 128 + SIGTERM(15)
+    }
+});
+process.on('SIGINT', () => {
+    try {
+        (0, errors_1.runCleanup)();
+    }
+    catch {
+        // Cleanup failure should not block termination.
+    }
+    // Same coordination rule as SIGTERM.
+    if (process.listenerCount('SIGINT') <= 1) {
+        process.exit(130); // 128 + SIGINT(2)
+    }
+});
+// Run main
+main().catch(errors_1.handleError);
+//# sourceMappingURL=ccs.js.map