praxis-agent 0.43.1 → 0.44.0

package/dist/cli-runtime.js

@@ -33,7 +33,7 @@ import { createClaudeModelAutoClassifier, defaultClaudeAutoModeConfig, loadClaud
 import { ClaudeExtensionPermissionResolver, ClaudeExtensionToolRegistry, } from './extensions/claude-extension-tools.js';
 import { ClaudeExtensionCatalog } from './extensions/claude-extensions.js';
 import { ClaudeHookRunner } from './hooks/claude-hooks.js';
-import { allowedWorkspaceHookSettings, allowedWorkspaceMcpResources, assessWorkspaceTrust, persistWorkspaceTrust, workspaceTrustDecisionKey, workspaceTrustInventory, } from './security/workspace-trust.js';
+import { allowedWorkspaceHookSettings, allowedWorkspaceMcpResources, assessWorkspaceTrust, hasWorkspaceProviderSelection, persistWorkspaceTrust, workspaceTrustDecisionKey, workspaceTrustInventory, } from './security/workspace-trust.js';
 import { createWorkspaceTrustDecisionCache, promptWorkspaceTrust, safeWorkspaceTrustDisplayField, } from './cli/workspace-trust-prompt.js';
 import { ClaudeSessionEnvironment } from './hooks/claude-session-environment.js';
 import { ClaudeMcpToolRegistry, } from './mcp/claude-mcp-tools.js';
@@ -42,14 +42,17 @@ import { authenticateMcpServer, ClaudeMcpOAuthStore, mcpOAuthServerIdentity, rea
 import { servePraxisMcpStdio } from './mcp/praxis-mcp-server.js';
 const VERIFIED_CLAUDE_SCHEMA_VERSION = 'native';
 const isClaudeSessionId = isSessionId;
+function truthyEnvironmentValue(value) {
+    return /^(?:1|true|yes|on)$/iu.test((value ?? '').trim());
+}
 import { writeFileAtomically } from './platform/atomic-write.js';
 import { redactSensitiveText, sensitiveEnvironmentValues, } from './platform/sensitive-data.js';
-import { AnthropicCompatibleProvider } from './providers/anthropic-compatible.js';
-import { createAnthropicPromptCachePolicyResolver } from './providers/anthropic-prompt-cache.js';
 import { FallbackModelProvider } from './providers/fallback-provider.js';
-import { DeadlineModelProvider } from './providers/deadline-provider.js';
-import { OpenAICompatibleProvider } from './providers/openai-compatible.js';
+import { ProviderCredentialVault } from './persistence/provider-credential-vault.js';
 import { parseContextEnvironment, parseProviderEnvironment, } from './providers/environment.js';
+import { ProviderAuthenticationError, resolveProviderCredential, } from './providers/provider-auth.js';
+import { resolveProviderRegistry } from './providers/provider-registry.js';
+import { ProviderSettingsError, resolveProviderTarget, } from './providers/provider-settings.js';
 import { ModelPricingRegistry, usageCostUsd } from './core/usage.js';
 import { LocalToolRegistry } from './tools/local-tools.js';
 import { ClaudeLspToolManager } from './tools/claude-lsp-tool.js';
@@ -63,6 +66,7 @@ import { launchTmuxWorktree } from './platform/tmux-worktree.js';
 import { claudeSandboxRuntime } from './sandbox/claude-sandbox-runtime.js';
 import { nativeSandboxTempDirectory, loadClaudeSandboxSettings, } from './sandbox/claude-sandbox-settings.js';
 import { createErrorResult, createSuccessResult, isHeadlessCostCommand, matchHeadlessColorCommand, parseCliInvocation, readStreamJsonMessages, StreamJsonOutput, } from './cli/protocol.js';
+import { executeProviderAuthCommand } from './cli/provider-auth-command.js';
 import { describeClaudePlugin, initClaudePlugin, installClaudePlugin, loadClaudePlugins, readPluginRegistry, setClaudePluginEnabled, uninstallClaudePlugin, updateClaudePlugin, validateClaudePlugin, } from './plugins/claude-plugin-runtime.js';
 import { addClaudeMarketplace, disableAllNativePlugins, installClaudeMarketplacePlugin, listClaudeMarketplaceAvailablePlugins, listNativePluginRecords, readClaudeKnownMarketplaces, removeClaudeMarketplace, setNativePluginEnabled, saveClaudePluginConfig, uninstallNativePlugin, updateClaudeMarketplace, updateNativePlugin, validateClaudeMarketplace, } from './plugins/claude-plugin-marketplace.js';
 import { executeClaudePluginEvalCommand, PLUGIN_EVAL_HELP, } from './plugins/claude-plugin-eval.js';
@@ -97,60 +101,6 @@ function fileResourceHeaders(environment, providerEnvironment, credential) {
             : {}),
     };
 }
-function createProviderForModel({ apiKey, environment, provider, context, controls, explicitThinkingControls, }) {
-    const resolvePromptCachePolicy = createAnthropicPromptCachePolicyResolver(environment);
-    return (selectedModel) => {
-        const providerOptions = {
-            apiKey,
-            model: selectedModel,
-            baseUrl: provider.baseUrl,
-            ...('contextWindowTokens' in context
-                ? { contextWindowTokens: context.contextWindowTokens }
-                : {}),
-        };
-        const concrete = provider.provider === 'anthropic'
-            ? new AnthropicCompatibleProvider({
-                ...providerOptions,
-                promptCaching: resolvePromptCachePolicy({
-                    baseUrl: provider.baseUrl,
-                    model: selectedModel,
-                }),
-                thinking: {
-                    mode: controls.thinking ?? 'enabled',
-                    ...(controls.maxThinkingTokens === undefined
-                        ? {}
-                        : { maxTokens: controls.maxThinkingTokens }),
-                },
-                ...('maxOutputTokens' in provider
-                    ? { maxOutputTokens: provider.maxOutputTokens }
-                    : {}),
-                ...('anthropicVersion' in provider
-                    ? { anthropicVersion: provider.anthropicVersion }
-                    : {}),
-                ...('webSearch' in provider
-                    ? { webSearch: provider.webSearch }
-                    : {}),
-            })
-            : new OpenAICompatibleProvider({
-                ...providerOptions,
-                ...(explicitThinkingControls.thinking === undefined &&
-                    explicitThinkingControls.maxThinkingTokens === undefined
-                    ? {}
-                    : {
-                        thinking: {
-                            mode: controls.thinking ?? 'enabled',
-                            ...(controls.maxThinkingTokens === undefined
-                                ? {}
-                                : { maxTokens: controls.maxThinkingTokens }),
-                        },
-                    }),
-            });
-        return new DeadlineModelProvider({
-            provider: concrete,
-            deadlineMs: provider.deadlineMs,
-        });
-    };
-}
 const HELP = `Praxis — local-first general agent
 
 Usage:
@@ -174,6 +124,7 @@ Usage:
   praxis auto-mode <config|defaults|critique>
   praxis plugin|plugins <details|list|install|uninstall|enable|disable|update|init|prune|tag|validate|marketplace> ...
   praxis doctor [--json]
+  praxis auth <status|set-key|login|logout> ...
   praxis import [options] [source]
   praxis install [--force] [stable|latest|version]
   praxis update|upgrade
@@ -189,6 +140,8 @@ Options:
   --resume-session-at <message-id>    Resume at an active conversation message
   --session-id <uuid>                 Use an explicit ID for a new session
   -n, --name <name>                   Set session display name
+  --provider <id>                     Select provider for this session
+  --provider-profile <id>             Select provider profile for this session
   --model <model>                     Select model for this session
   --effort <level>                    low, medium, high, xhigh, or max
   --environment <environment_id>      Unsupported: Praxis runs sessions locally
@@ -225,7 +178,7 @@ Options:
   --setting-sources <sources>         user, project, local, or an empty list
   --safe-mode                         Disable shared customizations
   --bare                              Use only explicitly supplied context
-  --trust-project                     Trust current workspace executables
+  --trust-project                     Trust current workspace-controlled resources/configuration
   --system-prompt <prompt>            Set system prompt
   --append-system-prompt <prompt>     Append system prompt
   --exclude-dynamic-system-prompt-sections
@@ -259,13 +212,65 @@ Options:
   --tmux[=classic]                    Launch worktree in an iTerm2 native pane when available; classic forces tmux
 
 Provider environment:
-  PRAXIS_PROVIDER=openai|anthropic, PRAXIS_API_KEY, PRAXIS_MODEL
+  PRAXIS_PROVIDER=<provider-id>, PRAXIS_API_KEY, PRAXIS_MODEL
+  PRAXIS_PROVIDER_PROFILE
   PRAXIS_BASE_URL, PRAXIS_MAX_OUTPUT_TOKENS, PRAXIS_ANTHROPIC_VERSION
   PRAXIS_ANTHROPIC_WEB_SEARCH=true|false
   PRAXIS_ANTHROPIC_PROMPT_CACHING=true|false
   PRAXIS_ANTHROPIC_PROMPT_CACHE_TTL=5m|1h
   PRAXIS_CONTEXT_WINDOW_TOKENS, PRAXIS_CONTEXT_RESERVE_TOKENS
 `;
+const AUTH_HELP = `Usage: praxis auth <command>
+
+Commands:
+  status [provider] [--profile <profile>] [--json]
+  set-key <provider> [--profile <profile>] [--json]
+  login openai-codex [--profile <profile>] [--device] [--no-browser] [--json]
+  logout <provider> [--profile <profile>] [--json]
+
+Options:
+  -h, --help  Display help for command
+`;
+const AUTH_ACTION_HELP = {
+    status: `Usage: praxis auth status [provider] [--profile <profile>] [--json]
+
+List credential metadata without exposing secrets.
+
+Options:
+  --profile <profile>  Filter by provider profile
+  --json               Output machine-readable metadata
+  -h, --help           Display help for command
+`,
+    'set-key': `Usage: praxis auth set-key <provider> [--profile <profile>] [--json]
+
+Read an API key securely from the terminal or stdin and store it in the native Vault.
+
+Options:
+  --profile <profile>  Select provider profile (default: default)
+  --json               Output a machine-readable confirmation
+  -h, --help           Display help for command
+`,
+    login: `Usage: praxis auth login openai-codex [--profile <profile>] [--device] [--no-browser] [--json]
+
+Authorize an experimental Codex subscription profile with OpenAI OAuth.
+
+Options:
+  --profile <profile>  Select Codex profile (default: default)
+  --device             Use the device authorization flow
+  --no-browser         Print instructions without opening a browser
+  --json               Keep stdout machine-readable
+  -h, --help           Display help for command
+`,
+    logout: `Usage: praxis auth logout <provider> [--profile <profile>] [--json]
+
+Delete exactly one native Vault credential.
+
+Options:
+  --profile <profile>  Select provider profile (default: default)
+  --json               Output a machine-readable confirmation
+  -h, --help           Display help for command
+`,
+};
 const AGENTS_HELP = `Usage: praxis agents [options]
 
 Manage background agents
@@ -296,6 +301,10 @@ Options:
                                         dispatched sessions (repeatable)
   --model <model>                       Default model for sessions dispatched
                                         from agent view
+  --provider <id>                       Default provider for sessions dispatched
+                                        from agent view
+  --provider-profile <id>               Default provider profile for dispatched
+                                        sessions
   --permission-mode <mode>              Default permission mode for sessions
                                         dispatched from agent view
   --plugin-dir <path>                   Load plugins from specified directory
@@ -759,11 +768,119 @@ Commands:
   attach <team-id> [--json]
 `;
 export { parseContextEnvironment, parseProviderEnvironment };
+export async function readConsoleSecret(prompt, signal, input = process.stdin, output = process.stderr) {
+    const limit = 64 * 1024;
+    if (signal?.aborted)
+        throw new Error('Credential input cancelled');
+    if (!input.isTTY || typeof input.setRawMode !== 'function') {
+        const chunks = [];
+        let size = 0;
+        for await (const chunk of input) {
+            if (signal?.aborted)
+                throw new Error('Credential input cancelled');
+            const bytes = typeof chunk === 'string' ? Buffer.from(chunk) : Buffer.from(chunk);
+            size += bytes.byteLength;
+            if (size > limit)
+                throw new Error('Credential exceeds the 64 KiB limit');
+            chunks.push(bytes);
+        }
+        if (signal?.aborted)
+            throw new Error('Credential input cancelled');
+        return Buffer.concat(chunks, size).toString('utf8');
+    }
+    output.write(prompt);
+    const wasRaw = input.isRaw;
+    const wasPaused = input.isPaused();
+    const value = [];
+    return await new Promise((resolveSecret, reject) => {
+        let settled = false;
+        let rawModeChanged = false;
+        let listenerAttached = false;
+        const restore = () => {
+            let failure;
+            if (listenerAttached) {
+                input.removeListener('data', onData);
+                listenerAttached = false;
+            }
+            signal?.removeEventListener('abort', onAbort);
+            if (rawModeChanged) {
+                try {
+                    input.setRawMode?.(Boolean(wasRaw));
+                }
+                catch (error) {
+                    failure = error instanceof Error ? error : new Error(String(error));
+                }
+                rawModeChanged = false;
+            }
+            if (wasPaused) {
+                try {
+                    input.pause();
+                }
+                catch (error) {
+                    failure ??= error instanceof Error ? error : new Error(String(error));
+                }
+            }
+            return failure;
+        };
+        const finish = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            const restorationError = restore();
+            let outputError;
+            try {
+                output.write('\n');
+            }
+            catch (writeError) {
+                outputError =
+                    writeError instanceof Error
+                        ? writeError
+                        : new Error(String(writeError));
+            }
+            const failure = error ?? restorationError ?? outputError;
+            if (failure)
+                reject(failure);
+            else
+                resolveSecret(Buffer.from(value).toString('utf8'));
+        };
+        const onAbort = () => finish(new Error('Credential input cancelled'));
+        const onData = (chunk) => {
+            const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            for (const byte of bytes) {
+                if (byte === 3)
+                    return finish(new Error('Credential input cancelled'));
+                if (byte === 13 || byte === 10)
+                    return finish();
+                if (byte === 8 || byte === 127) {
+                    value.pop();
+                    continue;
+                }
+                value.push(byte);
+                if (value.length > limit)
+                    return finish(new Error('Credential exceeds the 64 KiB limit'));
+            }
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+        if (signal?.aborted)
+            return onAbort();
+        try {
+            input.setRawMode?.(true);
+            rawModeChanged = true;
+            input.resume();
+            input.on('data', onData);
+            listenerAttached = true;
+        }
+        catch (error) {
+            finish(error instanceof Error ? error : new Error(String(error)));
+        }
+    });
+}
 const consoleIO = {
     stdout: (message) => process.stdout.write(message),
     stderr: (message) => process.stderr.write(message),
     isTTY: Boolean(process.stdin.isTTY && process.stdout.isTTY),
     readStdinLines: () => process.stdin,
+    readSecret: readConsoleSecret,
 };
 function warningEventSink(io) {
     return (event) => {
@@ -801,6 +918,34 @@ export function resolveInteractiveRuntimeSettingsLocation(dataPlane, environment
         statePath: join(configRoot, 'state.json'),
     };
 }
+async function assessCurrentWorkspaceProviderSelection(options) {
+    const shared = await loadNativeSharedResources({
+        root: options.configRoot,
+        cwd: options.cwd,
+        environment: options.environment,
+        includeProjectMemory: false,
+    });
+    const plugins = await loadClaudePlugins({
+        configRoot: options.configRoot,
+        cwd: options.cwd,
+        pluginDirectories: options.pluginDirectories ?? [],
+        pluginUrls: options.pluginUrls ?? [],
+        strictPluginDirectories: (options.pluginDirectories?.length ?? 0) +
+            (options.pluginUrls?.length ?? 0) >
+            0,
+        loadInstalled: true,
+        readOnlyExecutables: true,
+        environment: options.environment,
+    });
+    const settings = [...shared.settings, ...plugins.settings];
+    if (!hasWorkspaceProviderSelection(settings))
+        return undefined;
+    return assessWorkspaceTrust(await workspaceTrustInventory({
+        cwd: options.cwd,
+        settings,
+        mcp: options.strictMcpConfig ? [] : [...shared.mcp, ...plugins.mcp],
+    }), options.statePath);
+}
 export function resolveUnknownCostSidecarPath(dataPlane, configRoot) {
     assertNativeDataPlane(dataPlane);
     return join(configRoot, 'state', 'unknown-cost-sidecar.json');
@@ -820,7 +965,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
     });
     const claudeStatePath = join(configRoot, 'state.json');
     const simpleMode = controls.bare ||
-        /^(?:1|true|yes|on)$/iu.test((runtimeEnvironment.CLAUDE_CODE_SIMPLE ?? '').trim());
+        truthyEnvironmentValue(runtimeEnvironment.CLAUDE_CODE_SIMPLE);
     const runtimeSettings = controls.safeMode || simpleMode
         ? undefined
         : await loadRuntimeSettings({ configRoot, statePath: claudeStatePath });
@@ -881,48 +1026,145 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
     let provider;
     let providerForModel;
     let providerForMainModel;
+    let providerBillingMode;
     const context = parseContextEnvironment(runtimeEnvironment);
     const apiKey = runtimeEnvironment.PRAXIS_API_KEY;
-    const model = resolveRuntimeModel(interactiveModel ?? controls.model, runtimeEnvironment, runtimeSettings);
-    const providerEnvironment = apiKey && model
+    let model = resolveRuntimeModel(interactiveModel ?? controls.model, runtimeEnvironment, runtimeSettings);
+    const providerEnvironment = cli.fileResources.length > 0
         ? parseProviderEnvironment(runtimeEnvironment)
-        : cli.fileResources.length > 0
-            ? parseProviderEnvironment(runtimeEnvironment)
-            : undefined;
+        : undefined;
     const fileCredential = runtimeEnvironment.PRAXIS_FILES_BEARER_TOKEN ??
         runtimeEnvironment.PRAXIS_FILES_API_KEY ??
         apiKey;
     if (cli.fileResources.length > 0 && !fileCredential) {
         throw new Error('--file requires PRAXIS_FILES_BEARER_TOKEN, PRAXIS_FILES_API_KEY, or PRAXIS_API_KEY');
     }
-    if (requireProvider && (!apiKey || !model)) {
-        throw new Error('PRAXIS_API_KEY and a model (--model or PRAXIS_MODEL) are required');
-    }
-    if (!hooksOnly && apiKey && model) {
-        if (!providerEnvironment) {
-            throw new Error('Provider environment is unavailable');
+    const warnedWorkspaceFingerprints = new Set();
+    let trustProjectRequestAvailable = cli.trustProject;
+    const authorizeWorkspaceResources = async (automaticSettings, automaticMcp, runtimeCwd, precomputedAssessment) => {
+        if (cli.safeMode || simpleMode)
+            return true;
+        const trustRequested = trustProjectRequestAvailable;
+        trustProjectRequestAvailable = false;
+        const assessment = precomputedAssessment ??
+            (await assessWorkspaceTrust(await workspaceTrustInventory({
+                cwd: runtimeCwd,
+                settings: automaticSettings,
+                mcp: automaticMcp,
+            }), claudeStatePath));
+        if (assessment.status !== 'untrusted')
+            return true;
+        let approved = trustRequested;
+        if (!approved && approveWorkspaceTrust) {
+            try {
+                approved = await approveWorkspaceTrust(assessment);
+            }
+            catch (error) {
+                if (!(error instanceof Error &&
+                    (error.name === 'AbortError' || error.name === 'CancellationError'))) {
+                    throw error;
+                }
+                approved = false;
+            }
+        }
+        if (approved) {
+            await persistWorkspaceTrust(assessment, claudeStatePath);
+            return true;
         }
-        providerForModel = createProviderForModel({
-            apiKey,
+        const warningKey = workspaceTrustDecisionKey(assessment);
+        if (!warnedWorkspaceFingerprints.has(warningKey)) {
+            warnedWorkspaceFingerprints.add(warningKey);
+            runtimeEventSink({
+                type: 'warning',
+                message: `Workspace-controlled resources/configuration blocked for ${safeWorkspaceTrustDisplayField(assessment.canonicalPath)}; restart to review them interactively, or rerun with --trust-project to approve the current fingerprint.`,
+            });
+        }
+        return false;
+    };
+    let workspaceProviderSettingsTrusted = false;
+    if (!hooksOnly && !cli.safeMode && !simpleMode) {
+        const assessment = await assessCurrentWorkspaceProviderSelection({
+            configRoot,
+            statePath: claudeStatePath,
+            cwd,
             environment: runtimeEnvironment,
-            dataPlane,
-            provider: providerEnvironment,
-            context,
-            controls: cli,
-            explicitThinkingControls: controls,
+            pluginDirectories: cli.pluginDirectories,
+            pluginUrls: cli.pluginUrls,
+            strictMcpConfig: cli.strictMcpConfig,
         });
-        const createProvider = providerForModel;
-        providerForMainModel = (primaryModel) => {
-            const models = [primaryModel, ...(cli.fallbackModels ?? [])].filter((candidate, index, all) => all.indexOf(candidate) === index);
-            const providers = models.map((candidate) => createProvider(candidate));
-            const selected = providers[0];
-            if (!selected)
-                throw new Error('A primary model is required');
-            return providers.length > 1
-                ? new FallbackModelProvider({ providers })
-                : selected;
-        };
-        provider = providerForMainModel(model);
+        if (assessment) {
+            workspaceProviderSettingsTrusted = await authorizeWorkspaceResources([], [], cwd, assessment);
+        }
+    }
+    if (!hooksOnly) {
+        try {
+            const registry = await resolveProviderRegistry({
+                configRoot,
+                cwd,
+                environment: runtimeEnvironment,
+                ...((interactiveModel ?? controls.model) === undefined
+                    ? {}
+                    : { model: interactiveModel ?? controls.model }),
+                ...(controls.provider === undefined
+                    ? {}
+                    : { provider: controls.provider }),
+                ...(controls.providerProfile === undefined
+                    ? {}
+                    : { profile: controls.providerProfile }),
+                includeSettings: !(controls.safeMode || simpleMode),
+                includeProjectSettings: workspaceProviderSettingsTrusted,
+                context,
+                vault: new ProviderCredentialVault({
+                    configRoot,
+                    environment: runtimeEnvironment,
+                }),
+                anthropicThinking: {
+                    mode: cli.thinking ?? 'enabled',
+                    ...(cli.maxThinkingTokens === undefined
+                        ? {}
+                        : { maxTokens: cli.maxThinkingTokens }),
+                },
+                codexThinking: {
+                    mode: cli.thinking ?? 'enabled',
+                    ...(cli.maxThinkingTokens === undefined
+                        ? {}
+                        : { maxTokens: cli.maxThinkingTokens }),
+                },
+                ...(controls.thinking === undefined &&
+                    controls.maxThinkingTokens === undefined
+                    ? {}
+                    : {
+                        openAiThinking: {
+                            mode: cli.thinking ?? 'enabled',
+                            ...(cli.maxThinkingTokens === undefined
+                                ? {}
+                                : { maxTokens: cli.maxThinkingTokens }),
+                        },
+                    }),
+            });
+            model = registry.target.modelId;
+            providerBillingMode = registry.target.billingMode;
+            providerForModel = (selectedModel) => registry.create(selectedModel);
+            const createProvider = providerForModel;
+            providerForMainModel = (primaryModel) => {
+                const models = [primaryModel, ...(cli.fallbackModels ?? [])].filter((candidate, index, all) => all.indexOf(candidate) === index);
+                const providers = models.map((candidate) => createProvider(candidate));
+                const selected = providers[0];
+                if (!selected)
+                    throw new Error('A primary model is required');
+                return providers.length > 1
+                    ? new FallbackModelProvider({ providers })
+                    : selected;
+            };
+            provider = providerForMainModel(model);
+        }
+        catch (error) {
+            const optionalProviderError = error instanceof ProviderAuthenticationError ||
+                (error instanceof ProviderSettingsError &&
+                    error.code === 'model_required');
+            if (requireProvider || !optionalProviderError)
+                throw error;
+        }
     }
     const costStateStore = new ClaudeCostStateStore({
         statePath: claudeStatePath,
@@ -957,7 +1199,11 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
         ...(cli.maxBudgetUsd === undefined
             ? {}
             : { maxBudgetUsd: cli.maxBudgetUsd }),
-        pricing: ModelPricingRegistry.fromEnvironment(runtimeEnvironment.PRAXIS_PRICING_JSON),
+        ...(providerBillingMode === 'subscription'
+            ? {}
+            : {
+                pricing: ModelPricingRegistry.fromEnvironment(runtimeEnvironment.PRAXIS_PRICING_JSON),
+            }),
         collectMetrics: true,
         ...(!experimentalNativeTranscriptWrites && sessionMemoryProviderFactory
             ? { sessionMemoryProviderFactory }
@@ -987,48 +1233,6 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             }
             : {}),
     };
-    const warnedWorkspaceFingerprints = new Set();
-    let trustProjectRequestAvailable = cli.trustProject;
-    const authorizeWorkspaceExecutables = async (automaticSettings, automaticMcp, runtimeCwd) => {
-        if (cli.safeMode || simpleMode)
-            return true;
-        const trustRequested = trustProjectRequestAvailable;
-        trustProjectRequestAvailable = false;
-        const inventory = await workspaceTrustInventory({
-            cwd: runtimeCwd,
-            settings: automaticSettings,
-            mcp: automaticMcp,
-        });
-        const assessment = await assessWorkspaceTrust(inventory, claudeStatePath);
-        if (assessment.status !== 'untrusted')
-            return true;
-        let approved = trustRequested;
-        if (!approved && approveWorkspaceTrust) {
-            try {
-                approved = await approveWorkspaceTrust(assessment);
-            }
-            catch (error) {
-                if (!(error instanceof Error &&
-                    (error.name === 'AbortError' || error.name === 'CancellationError'))) {
-                    throw error;
-                }
-                approved = false;
-            }
-        }
-        if (approved) {
-            await persistWorkspaceTrust(assessment, claudeStatePath);
-            return true;
-        }
-        const warningKey = workspaceTrustDecisionKey(assessment);
-        if (!warnedWorkspaceFingerprints.has(warningKey)) {
-            warnedWorkspaceFingerprints.add(warningKey);
-            runtimeEventSink({
-                type: 'warning',
-                message: `Workspace executable resources blocked for ${safeWorkspaceTrustDisplayField(assessment.canonicalPath)}; restart to review them interactively, or rerun with --trust-project to approve the current fingerprint.`,
-            });
-        }
-        return false;
-    };
     const hookConfiguration = async () => {
         const [sharedResources, pluginResources] = await Promise.all([
             cli.safeMode || simpleMode
@@ -1057,7 +1261,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
         const automaticMcp = cli.strictMcpConfig
             ? []
             : [...sharedResources.mcp, ...pluginResources.mcp];
-        const trusted = await authorizeWorkspaceExecutables(automaticSettings, automaticMcp, cwd);
+        const trusted = await authorizeWorkspaceResources(automaticSettings, automaticMcp, cwd);
         return projectTuiHooks([
             ...allowedWorkspaceHookSettings(automaticSettings, trusted),
             ...(cli.additionalSettings ? [cli.additionalSettings] : []),
@@ -1155,7 +1359,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
     const trustMcp = cli.strictMcpConfig
         ? []
         : [...loadedResources.mcp, ...executablePluginResources.mcp];
-    const workspaceExecutablesTrusted = await authorizeWorkspaceExecutables(trustSettings, trustMcp, cwd);
+    const workspaceExecutablesTrusted = await authorizeWorkspaceResources(trustSettings, trustMcp, cwd);
     const loadedPluginResources = await loadClaudePlugins({
         ...pluginLoadOptions,
         allowWorkspaceMcpb: workspaceExecutablesTrusted,
@@ -1406,7 +1610,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                 ...pluginResources.settings,
             ];
             const refreshedMcp = [...refreshed.mcp, ...pluginResources.mcp];
-            const trusted = await authorizeWorkspaceExecutables(refreshedSettings, refreshedMcp, workspace.cwd());
+            const trusted = await authorizeWorkspaceResources(refreshedSettings, refreshedMcp, workspace.cwd());
             return runtimeMcpResources([
                 ...allowedWorkspaceMcpResources(refreshedMcp, trusted),
                 ...cli.mcpResources,
@@ -1994,30 +2198,31 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
         throw error;
     }
 };
-const createDefaultAutoModeCritic = async ({ model, dataPlane, configRoot, statePath }) => {
-    const apiKey = process.env.PRAXIS_API_KEY;
+const createDefaultAutoModeCritic = async ({ model, provider, providerProfile, dataPlane, configRoot, statePath, }) => {
     const resolvedDataPlane = dataPlane ?? resolveDataPlane();
     const location = resolveInteractiveRuntimeSettingsLocation(resolvedDataPlane);
     const resolvedConfigRoot = configRoot ?? location.configRoot;
-    const resolvedStatePath = statePath ?? location.statePath;
-    const runtimeSettings = await loadRuntimeSettings({
+    const assessment = await assessCurrentWorkspaceProviderSelection({
         configRoot: resolvedConfigRoot,
-        statePath: resolvedStatePath,
+        statePath: statePath ?? join(resolvedConfigRoot, 'state.json'),
+        cwd: process.cwd(),
+        environment: process.env,
     });
-    const selectedModel = resolveRuntimeModel(model, process.env, runtimeSettings);
-    if (!apiKey || !selectedModel) {
-        throw new Error('PRAXIS_API_KEY and a model (--model or PRAXIS_MODEL) are required');
-    }
-    const providerEnvironment = parseProviderEnvironment(process.env);
-    return createProviderForModel({
-        apiKey,
+    const registry = await resolveProviderRegistry({
+        configRoot: resolvedConfigRoot,
+        cwd: process.cwd(),
         environment: process.env,
-        dataPlane: resolvedDataPlane,
-        provider: providerEnvironment,
+        ...(model === undefined ? {} : { model }),
+        ...(provider === undefined ? {} : { provider }),
+        ...(providerProfile === undefined ? {} : { profile: providerProfile }),
+        includeProjectSettings: assessment?.status === 'trusted',
         context: parseContextEnvironment(process.env),
-        controls: {},
-        explicitThinkingControls: {},
-    })(selectedModel);
+        vault: new ProviderCredentialVault({
+            configRoot: resolvedConfigRoot,
+            environment: process.env,
+        }),
+    });
+    return registry.create(model ?? registry.target.modelId);
 };
 const defaultPluginEvalRuntimeFactory = {
     create: async (options) => {
@@ -2108,19 +2313,29 @@ const defaultPluginEvalRuntimeFactory = {
 const defaultPluginEvalJudge = {
     vote: async ({ criteria, focus, baseline, model, signal }) => {
         const environment = process.env;
-        const apiKey = environment.PRAXIS_API_KEY;
-        if (!apiKey)
-            throw new Error('PRAXIS_API_KEY is required for paid eval graders');
-        const providerEnvironment = parseProviderEnvironment(environment);
-        const provider = createProviderForModel({
-            apiKey,
+        const configRoot = resolveDataPlaneRoot({ environment });
+        const assessment = await assessCurrentWorkspaceProviderSelection({
+            configRoot,
+            statePath: join(configRoot, 'state.json'),
+            cwd: process.cwd(),
             environment,
-            dataPlane: resolveDataPlane(environment),
-            provider: providerEnvironment,
+        });
+        const registry = await resolveProviderRegistry({
+            configRoot,
+            cwd: process.cwd(),
+            environment,
+            ...(model === undefined ? {} : { model }),
+            includeProjectSettings: assessment?.status === 'trusted',
             context: parseContextEnvironment(environment),
-            controls: {},
-            explicitThinkingControls: {},
-        })(model);
+            vault: new ProviderCredentialVault({
+                configRoot,
+                environment,
+            }),
+        });
+        if (registry.target.billingMode === 'subscription') {
+            throw new Error('Plugin eval LLM judges require API-billed cost; subscription cost is unavailable');
+        }
+        const provider = registry.create(model ?? registry.target.modelId);
         const prompt = `You are an eval judge. Return only JSON matching {"passed":boolean,"explanation":string}.
 
 Criteria:
@@ -2170,6 +2385,135 @@ ${focus}${baseline === undefined ? '' : `\n\nBaseline:\n${baseline}`}`;
         };
     },
 };
+async function resolveDetachedWorkerProviderEnvironment(request) {
+    const environment = process.env;
+    const invocation = parseCliInvocation(request.argv);
+    const configRoot = resolveDataPlaneRoot({ environment });
+    const statePath = join(configRoot, 'state.json');
+    const safe = invocation.safeMode ||
+        invocation.bare ||
+        truthyEnvironmentValue(environment.CLAUDE_CODE_SIMPLE);
+    let includeProjectSettings = false;
+    if (!safe) {
+        const assessment = await assessCurrentWorkspaceProviderSelection({
+            configRoot,
+            statePath,
+            cwd: request.cwd,
+            environment,
+            pluginDirectories: invocation.pluginDirectories,
+            pluginUrls: invocation.pluginUrls,
+            strictMcpConfig: invocation.strictMcpConfig,
+        });
+        if (assessment?.status === 'trusted')
+            includeProjectSettings = true;
+        else if (assessment?.status === 'untrusted' && invocation.trustProject) {
+            await persistWorkspaceTrust(assessment, statePath);
+            includeProjectSettings = true;
+        }
+    }
+    const target = await resolveProviderTarget({
+        configRoot,
+        cwd: request.cwd,
+        environment,
+        ...(invocation.model === undefined ? {} : { model: invocation.model }),
+        ...(invocation.provider === undefined
+            ? {}
+            : { provider: invocation.provider }),
+        ...(invocation.providerProfile === undefined
+            ? {}
+            : { profile: invocation.providerProfile }),
+        includeSettings: !safe,
+        includeProjectSettings,
+    });
+    const credential = await resolveProviderCredential({
+        target,
+        environment,
+        vault: new ProviderCredentialVault({ configRoot, environment }),
+    });
+    return credential.type === 'api-key'
+        ? { PRAXIS_API_KEY: credential.secret }
+        : {};
+}
+export async function resolveInteractiveProviderStartup(options) {
+    const environment = options.environment ?? process.env;
+    const disabled = options.controls.safeMode ||
+        options.controls.bare ||
+        truthyEnvironmentValue(environment.CLAUDE_CODE_SIMPLE);
+    if (disabled) {
+        let effectiveModel;
+        try {
+            effectiveModel = (await resolveProviderTarget({
+                configRoot: options.configRoot,
+                cwd: options.cwd,
+                environment,
+                ...(options.controls.model === undefined
+                    ? {}
+                    : { model: options.controls.model }),
+                ...(options.controls.provider === undefined
+                    ? {}
+                    : { provider: options.controls.provider }),
+                ...(options.controls.providerProfile === undefined
+                    ? {}
+                    : { profile: options.controls.providerProfile }),
+                includeSettings: false,
+            })).modelId;
+        }
+        catch (error) {
+            if (!(error instanceof ProviderSettingsError &&
+                error.code === 'model_required'))
+                throw error;
+        }
+        return {
+            effectiveModel,
+            trustProjectRequestAvailable: options.controls.trustProject,
+        };
+    }
+    const assessment = await assessCurrentWorkspaceProviderSelection({
+        configRoot: options.configRoot,
+        statePath: options.statePath,
+        cwd: options.cwd,
+        environment,
+        pluginDirectories: options.controls.pluginDirectories,
+        pluginUrls: options.controls.pluginUrls,
+        strictMcpConfig: options.controls.strictMcpConfig,
+    });
+    let includeProjectSettings = false;
+    let trustProjectRequestAvailable = options.controls.trustProject;
+    if (assessment) {
+        trustProjectRequestAvailable = false;
+        if (assessment.status === 'trusted')
+            includeProjectSettings = true;
+        else if (options.controls.trustProject ||
+            (await options.approveWorkspaceTrust?.(assessment))) {
+            await persistWorkspaceTrust(assessment, options.statePath);
+            includeProjectSettings = true;
+        }
+    }
+    let effectiveModel;
+    try {
+        effectiveModel = (await resolveProviderTarget({
+            configRoot: options.configRoot,
+            cwd: options.cwd,
+            environment,
+            ...(options.controls.model === undefined
+                ? {}
+                : { model: options.controls.model }),
+            ...(options.controls.provider === undefined
+                ? {}
+                : { provider: options.controls.provider }),
+            ...(options.controls.providerProfile === undefined
+                ? {}
+                : { profile: options.controls.providerProfile }),
+            includeSettings: true,
+            includeProjectSettings,
+        })).modelId;
+    }
+    catch (error) {
+        if (!(error instanceof ProviderSettingsError && error.code === 'model_required'))
+            throw error;
+    }
+    return { effectiveModel, trustProjectRequestAvailable };
+}
 export function createDefaultDependencies(entrypoint = fileURLToPath(import.meta.url)) {
     const dependencies = {
         createService: createDefaultService,
@@ -2193,13 +2537,15 @@ export function createDefaultDependencies(entrypoint = fileURLToPath(import.meta
             const initialAdditionalDirectories = interactiveControls.addDirectories.map((directory) => realpathSync(resolve(process.cwd(), directory)));
             const interactiveDataPlane = interactiveControls.dataPlane ?? resolveDataPlane();
             const { configRoot: interactiveConfigRoot, statePath: interactiveStatePath, } = resolveInteractiveRuntimeSettingsLocation(interactiveDataPlane);
-            const interactiveRuntimeSettings = interactiveControls.safeMode || interactiveControls.bare
-                ? undefined
-                : await loadRuntimeSettings({
-                    configRoot: interactiveConfigRoot,
-                    statePath: interactiveStatePath,
-                });
-            const effectiveModel = resolveRuntimeModel(interactiveControls.model, process.env, interactiveRuntimeSettings);
+            const startup = await resolveInteractiveProviderStartup({
+                controls: interactiveControls,
+                configRoot: interactiveConfigRoot,
+                statePath: interactiveStatePath,
+                cwd: process.cwd(),
+                approveWorkspaceTrust: cachedWorkspaceTrustDecision,
+            });
+            const effectiveModel = startup.effectiveModel;
+            const trustProjectRequestAvailable = startup.trustProjectRequestAvailable;
             const resumePath = typeof resume?.sessionSelector === 'string' &&
                 isResumePathSelector(resume.sessionSelector)
                 ? resume.sessionSelector
@@ -2218,7 +2564,7 @@ export function createDefaultDependencies(entrypoint = fileURLToPath(import.meta
                     ...(agent === undefined ? {} : { agent }),
                     controls: {
                         ...interactiveControls,
-                        trustProject: workspaceTrustPreflightOpen && interactiveControls.trustProject,
+                        trustProject: workspaceTrustPreflightOpen && trustProjectRequestAvailable,
                         addDirectories: options.additionalDirectories ??
                             interactiveControls.addDirectories,
                     },
@@ -2237,7 +2583,7 @@ export function createDefaultDependencies(entrypoint = fileURLToPath(import.meta
                 statePath: interactiveStatePath,
                 factory: {
                     createService: createInteractiveService,
-                    scheduledPrompts: Boolean(process.env.PRAXIS_API_KEY && effectiveModel),
+                    scheduledPrompts: Boolean(effectiveModel),
                 },
                 ...(signal ? { signal } : {}),
                 ...(initialPrompt === undefined ? {} : { initialPrompt }),
@@ -2311,6 +2657,7 @@ export function createDefaultDependencies(entrypoint = fileURLToPath(import.meta
             dataPlane,
             cwd: process.cwd(),
             cliPath: entrypoint,
+            resolveProviderEnvironment: resolveDetachedWorkerProviderEnvironment,
             version: VERSION,
         }),
         launchTmux: launchTmuxWorktree,
@@ -2689,6 +3036,12 @@ async function executeAutoModeCommand(args, invocation, io, dependencies, signal
         io.stdout('Analyzing your auto mode rules…\n\n');
         const provider = await (dependencies.createAutoModeCritic ?? createDefaultAutoModeCritic)({
             ...(invocation.model === undefined ? {} : { model: invocation.model }),
+            ...(invocation.provider === undefined
+                ? {}
+                : { provider: invocation.provider }),
+            ...(invocation.providerProfile === undefined
+                ? {}
+                : { providerProfile: invocation.providerProfile }),
             dataPlane,
             configRoot,
             statePath,
@@ -2760,21 +3113,27 @@ async function executeDoctorCommand(args, invocation, io) {
         configRoot,
         statePath: claudeStatePath,
     });
-    const effectiveModel = resolveRuntimeModel(invocation.model, process.env, runtimeSettings);
     const report = await runDoctor({
         version: VERSION,
         executablePath: fileURLToPath(import.meta.url),
         nodeExecutablePath: process.execPath,
         nodeVersion: process.version,
         configRoot,
+        claudeStatePath,
         cwd: process.cwd(),
-        environment: effectiveModel === undefined
-            ? { ...process.env, PRAXIS_DATA_PLANE: dataPlane }
-            : {
-                ...process.env,
-                PRAXIS_DATA_PLANE: dataPlane,
-                PRAXIS_MODEL: effectiveModel,
-            },
+        environment: {
+            ...process.env,
+            PRAXIS_DATA_PLANE: dataPlane,
+            ...(invocation.provider === undefined
+                ? {}
+                : { PRAXIS_PROVIDER: invocation.provider }),
+            ...(invocation.providerProfile === undefined
+                ? {}
+                : { PRAXIS_PROVIDER_PROFILE: invocation.providerProfile }),
+            ...(invocation.model === undefined
+                ? {}
+                : { PRAXIS_MODEL: invocation.model }),
+        },
         autoUpdateChannel: runtimeSettings.autoUpdatesChannel,
         ...(process.argv[1] === undefined
             ? {}
@@ -3939,8 +4298,16 @@ function backgroundWorkerArgv(argv) {
     }
     return filtered;
 }
-function agentDashboardWorkerArgv(invocation) {
+export function agentDashboardWorkerArgv(invocation) {
     const argv = [];
+    if (invocation.safeMode)
+        argv.push('--safe-mode');
+    if (invocation.bare)
+        argv.push('--bare');
+    if (invocation.provider !== undefined)
+        argv.push('--provider', invocation.provider);
+    if (invocation.providerProfile !== undefined)
+        argv.push('--provider-profile', invocation.providerProfile);
     if (invocation.model !== undefined)
         argv.push('--model', invocation.model);
     if (invocation.effort !== undefined)
@@ -3973,6 +4340,8 @@ function agentDashboardWorkerArgv(invocation) {
     for (const directory of invocation.pluginDirectories) {
         argv.push('--plugin-dir', directory);
     }
+    for (const url of invocation.pluginUrls)
+        argv.push('--plugin-url', url);
     return argv;
 }
 function backgroundLaunchMessage(id) {
@@ -3995,6 +4364,8 @@ function assertAgentsOptionAllowlist(argv) {
         '--effort',
         '--mcp-config',
         '--model',
+        '--provider',
+        '--provider-profile',
         '--permission-mode',
         '--plugin-dir',
         '--setting-sources',
@@ -4164,6 +4535,7 @@ function printCommandHelp(argv, io) {
         'auto-mode',
         'project',
         'import',
+        'auth',
         'team',
     ].includes(value));
     if (commandIndex < 0)
@@ -4252,6 +4624,19 @@ function printCommandHelp(argv, io) {
         io.stdout(IMPORT_HELP);
         return true;
     }
+    if (command === 'auth') {
+        const action = helpActionAt(argv, commandIndex, [
+            'help',
+            ...Object.keys(AUTH_ACTION_HELP),
+        ]);
+        if (!hasHelpFlag && action?.value !== 'help')
+            return false;
+        const target = action?.value === 'help'
+            ? helpActionAt(argv, action.index, Object.keys(AUTH_ACTION_HELP))
+            : action;
+        io.stdout(AUTH_ACTION_HELP[target?.value ?? ''] ?? AUTH_HELP);
+        return true;
+    }
     if (command === 'team') {
         if (!hasHelpFlag)
             return false;
@@ -4649,7 +5034,25 @@ async function execute(argv, io, dependencies, signal) {
         'upgrade',
         'project',
         'import',
+        'auth',
     ].includes(command ?? '');
+    if (command === 'auth') {
+        return (dependencies.executeProviderAuthCommand ?? executeProviderAuthCommand)(args, {
+            io,
+            configRoot: resolveDataPlaneRoot({ environment: process.env }),
+            environment: process.env,
+            ...(signal === undefined ? {} : { signal }),
+            ...(invocation.authProfile === undefined
+                ? {}
+                : { profile: invocation.authProfile }),
+            ...(invocation.providerProfile === undefined
+                ? {}
+                : { providerProfile: invocation.providerProfile }),
+            noBrowser: invocation.mcpNoBrowser,
+            json: invocation.legacyJson,
+            device: invocation.authDevice,
+        });
+    }
     if (args[0] === 'agents')
         assertAgentsOptionAllowlist(argv);
     const interactiveResume = invocation.resumeSelector !== undefined &&