praxis-agent 0.43.1 → 0.44.0

package/README.md

@@ -27,7 +27,9 @@ sessions, configuration, or compatibility directories.
 - macOS or Linux
 - Node.js 24 or newer
 - [`ripgrep`](https://github.com/BurntSushi/ripgrep) (`rg`) for the Grep tool
-- an API key and model ID for an Anthropic or OpenAI-compatible provider
+- an API key and model ID for an Anthropic or OpenAI-compatible provider (the
+  stable setup), or the explicitly enabled experimental ChatGPT-backed Codex
+  subscription integration
 
 Praxis does not use Claude subscription authentication. Claude-shaped message,
 tool, and CLI protocol forms remain supported where they are part of the
@@ -61,6 +63,15 @@ cd /path/to/project
 praxis
 ```
 
+Praxis also has an experimental `openai-codex` provider for ChatGPT-backed
+Codex subscriptions. It is separate from OpenAI API-key access, requires
+`experimental.codexSubscription: true`, and stores OAuth credentials in the
+native Vault. Start with `praxis auth login openai-codex`; see [Getting
+Started](docs/GETTING_STARTED.md) for the browser/device flow and limitations.
+This uses an undocumented third-party subscription/backend contract and may
+change; it is not Claude subscription authentication. Subscription runs retain
+token usage but do not provide API-dollar cost or enforce USD budgets.
+
 For Anthropic Messages:
 
 ```sh
@@ -154,11 +165,11 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   isolation, explicit ask/deny precedence, sandbox-only auto-allow,
   write-allowlist/deny-within-allow enforcement, per-command overrides and
   exclusions, violation reporting, and bare-repository control-file cleanup,
-  safe-property Skill auto-allow, interactive
-  workspace-directory add/remove controls, path confinement, credential
-  redaction, sanitized child processes, and exact-fingerprint workspace trust
-  that blocks automatically discovered project/local hooks and MCP servers
-  until the canonical workspace configuration is explicitly accepted.
+  safe-property Skill auto-allow, interactive workspace-directory add/remove
+  controls, path confinement, credential redaction, sanitized child processes,
+  and exact-fingerprint workspace trust that blocks automatically discovered
+  project/local provider selection, hooks, and MCP until the canonical
+  workspace configuration is accepted.
 - **Durable local work** — resumable sessions, full-history forks, file
   checkpoints, tasks, foreground/background subagents, top-level agents, and
   Claude-compatible main-thread agent definitions with native prompt, model,
@@ -187,9 +198,10 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   plugins, and append-only `praxis.transcript` JSONL sessions under `~/.praxis`,
   with bounded MCP connection, discovery, and tool operations plus safe
   disconnect recovery that never replays an already-dispatched call.
-- **Provider-neutral models** — native Anthropic Messages and OpenAI-compatible
-  streaming adapters with explicit capability checks, metering controls, and
-  a bounded absolute deadline for every provider attempt.
+- **Provider-neutral models** — native Provider Registry/Vault routing, API
+  adapters, an experimental Codex OAuth adapter, explicit capability checks,
+  per-attempt bounded deadlines, and token-only/no-API-dollar accounting for
+  subscription runs.
 - **Transactional self-update** — `praxis update` verifies the package before
   installing it, rejects concurrent updates, and can roll back after an
   interruption or crash.
@@ -216,7 +228,7 @@ not in this entry-point README.
 
 Praxis targets one local OS user working across multiple repositories and
 sessions. It is CLI-only and provider-capability-aware. Organization, tenant,
-RBAC, subscription authentication and billing, enterprise gateway,
+RBAC, billing, enterprise gateway,
 IDE/Desktop/mobile clients, Remote Control, Claude Desktop import, and hosted
 review-product surfaces are permanent non-goals.
 
@@ -251,6 +263,8 @@ implemented profile checks, not qualification of the full native package.
 injected regression protection, plus Quiet Operator input echo `<50 ms` and
 normal/low-capability full-frame p95 budgets of `<16.7/<33 ms`.
 `npm run check` also enforces the corresponding source dependency direction.
+`npm run test:coverage` measures all production code under `src/**` with V8 and
+enforces global floors of 79% statements, 70% branches, 85% functions, and 81% lines.
 `npm run test:core-completion` runs the 56-story #402 audit and reports
 implemented, qualified, blocked, deferred, and out-of-scope states separately;
 it never treats missing live prerequisites as a pass.

package/dist/application/top-level-agent-manager.d.ts

@@ -35,8 +35,15 @@ export interface TopLevelAgentManagerOptions {
     cliPath: string;
     executablePath?: string;
     environment?: NodeJS.ProcessEnv;
+    resolveProviderEnvironment?: (request: {
+        cwd: string;
+        argv: readonly string[];
+    }) => Promise<ProviderEnvironmentOverride>;
     version: string;
 }
+export interface ProviderEnvironmentOverride {
+    PRAXIS_API_KEY?: string;
+}
 export declare function topLevelAgentProcessRegistryRoot(configRoot: string, dataPlane?: DataPlane): string;
 export declare class TopLevelAgentManager {
     private readonly options;

package/dist/application/top-level-agent-manager.js

@@ -24,8 +24,11 @@ const SOCKET_RETRY_INTERVAL_MS = 25;
 // own provider from the same CLI/environment contract.
 const WORKER_RUNTIME_ENVIRONMENT = [
     'PRAXIS_API_KEY',
+    'CLAUDE_CODE_SIMPLE',
     'PRAXIS_MODEL',
     'PRAXIS_PROVIDER',
+    'PRAXIS_PROVIDER_PROFILE',
+    'PRAXIS_PROVIDER_DEADLINE_MS',
     'PRAXIS_BASE_URL',
     'PRAXIS_MAX_OUTPUT_TOKENS',
     'PRAXIS_ANTHROPIC_VERSION',
@@ -38,10 +41,11 @@ const WORKER_RUNTIME_ENVIRONMENT = [
     'PRAXIS_FILES_BASE_URL',
     'PRAXIS_FILES_BEARER_TOKEN',
     'PRAXIS_FILES_API_KEY',
+    'PRAXIS_PROVIDER_CREDENTIAL_STORE',
     'PRAXIS_MCP_OAUTH_STORE',
     'CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING',
 ];
-function workerEnvironment(source, configRoot) {
+function workerEnvironment(source, configRoot, resolved) {
     const environment = sanitizeChildEnvironment({ PATH: source.PATH }, {});
     for (const name of WORKER_RUNTIME_ENVIRONMENT) {
         const value = source[name];
@@ -50,6 +54,8 @@ function workerEnvironment(source, configRoot) {
     }
     environment.PRAXIS_DATA_PLANE = 'native';
     environment.PRAXIS_HOME = configRoot;
+    if (resolved?.PRAXIS_API_KEY !== undefined)
+        environment.PRAXIS_API_KEY = resolved.PRAXIS_API_KEY;
     return environment;
 }
 function socketPath(configRoot, id) {
@@ -285,8 +291,15 @@ export class TopLevelAgentManager {
             throw new Error('Could not allocate agent ID');
         const allocatedExecution = execution;
         let child;
+        let resolvedProviderEnvironment;
         const failLaunch = async (error) => {
-            const message = redactSensitiveText(error instanceof Error ? error.message : String(error), sensitiveEnvironmentValues(this.options.environment ?? process.env));
+            const sensitiveValues = [
+                ...sensitiveEnvironmentValues(this.options.environment ?? process.env),
+                ...(resolvedProviderEnvironment?.PRAXIS_API_KEY === undefined
+                    ? []
+                    : [resolvedProviderEnvironment.PRAXIS_API_KEY]),
+            ];
+            const message = redactSensitiveText(error instanceof Error ? error.message : String(error), sensitiveValues);
             const secondary = [];
             if (child?.pid !== undefined) {
                 try {
@@ -321,9 +334,14 @@ export class TopLevelAgentManager {
             throw new AggregateError([error, ...secondary], 'Could not start background agent');
         };
         try {
+            resolvedProviderEnvironment =
+                await this.options.resolveProviderEnvironment?.({
+                    cwd,
+                    argv: options.argv,
+                });
             child = spawn(this.options.executablePath ?? process.execPath, [this.options.cliPath, '__background-worker', identity.id], {
                 cwd,
-                env: workerEnvironment(this.options.environment ?? process.env, this.options.configRoot),
+                env: workerEnvironment(this.options.environment ?? process.env, this.options.configRoot, resolvedProviderEnvironment),
                 detached: true,
                 stdio: 'ignore',
             });

package/dist/cli/controls.js

@@ -206,6 +206,10 @@ export async function resolveCliControls(controls, cwd) {
         name: controls.name,
         sessionPersistence: controls.sessionPersistence,
         ...(controls.model === undefined ? {} : { model: controls.model }),
+        ...(controls.provider === undefined ? {} : { provider: controls.provider }),
+        ...(controls.providerProfile === undefined
+            ? {}
+            : { providerProfile: controls.providerProfile }),
         ...(controls.effort === undefined ? {} : { effort: controls.effort }),
         ...(controls.thinking === undefined ? {} : { thinking: controls.thinking }),
         ...(controls.maxThinkingTokens === undefined

package/dist/cli/protocol.d.ts

@@ -52,6 +52,8 @@ export interface CliControls {
     rewindFiles?: string;
     name: string | undefined;
     sessionPersistence: boolean;
+    provider?: string;
+    providerProfile?: string;
     model?: string;
     effort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
     thinking?: CliThinkingMode;
@@ -114,6 +116,9 @@ export interface CliInvocation extends CliControls {
     mcpClientSecret: boolean;
     mcpNoBrowser: boolean;
     mcpDebug: boolean;
+    /** Auth-command-only profile selector; distinct from providerProfile. */
+    authProfile?: string;
+    authDevice: boolean;
 }
 export interface StreamUserMessage {
     message: {

package/dist/cli/protocol.js

@@ -387,6 +387,8 @@ export function parseCliInvocation(argv) {
     let worktreeRequested = false;
     let tmux;
     let model;
+    let provider;
+    let providerProfile;
     let effort;
     let thinking;
     let maxThinkingTokens;
@@ -404,6 +406,8 @@ export function parseCliInvocation(argv) {
     let mcpClientSecret = false;
     let mcpNoBrowser = false;
     let mcpDebug = false;
+    let authProfile;
+    let authDevice = false;
     for (let index = 0; index < argv.length; index += 1) {
         const value = argv[index];
         if (value === undefined)
@@ -444,6 +448,30 @@ export function parseCliInvocation(argv) {
             index += selectedModel.consumed;
             continue;
         }
+        const selectedProvider = optionValue(argv, index, '--provider');
+        if (selectedProvider) {
+            if (provider !== undefined)
+                throw new Error('--provider may only be specified once');
+            provider = selectedProvider.value;
+            index += selectedProvider.consumed;
+            continue;
+        }
+        const selectedProviderProfile = optionValue(argv, index, '--provider-profile');
+        if (selectedProviderProfile) {
+            if (providerProfile !== undefined)
+                throw new Error('--provider-profile may only be specified once');
+            providerProfile = selectedProviderProfile.value;
+            index += selectedProviderProfile.consumed;
+            continue;
+        }
+        const selectedAuthProfile = optionValue(argv, index, '--profile');
+        if (selectedAuthProfile) {
+            if (authProfile !== undefined)
+                throw new Error('--profile may only be specified once');
+            authProfile = selectedAuthProfile.value;
+            index += selectedAuthProfile.consumed;
+            continue;
+        }
         const selectedAutocompact = optionValue(argv, index, '--autocompact');
         if (selectedAutocompact) {
             if (autocompact !== undefined)
@@ -1123,6 +1151,10 @@ export function parseCliInvocation(argv) {
             mcpNoBrowser = true;
             continue;
         }
+        if (value === '--device') {
+            authDevice = true;
+            continue;
+        }
         if (value === '--json') {
             legacyJson = true;
             continue;
@@ -1174,6 +1206,14 @@ export function parseCliInvocation(argv) {
     if (debug !== undefined && args[0] === 'mcp' && args[1] === 'serve') {
         mcpDebug = true;
     }
+    if (authProfile !== undefined && args[0] !== 'auth')
+        throw new Error('--profile is only valid with auth commands');
+    if (authDevice && !(args[0] === 'auth' && args[1] === 'login'))
+        throw new Error('--device is only valid with auth login');
+    if (mcpNoBrowser &&
+        !((args[0] === 'mcp' && args[1] === 'login') ||
+            (args[0] === 'auth' && args[1] === 'login')))
+        throw new Error('--no-browser is only valid with mcp login or auth login');
     if (background && print) {
         throw new Error("--bg and --print conflict: --print never starts the interactive session that `claude agents` attaches to, so the job would be unattachable. The prompt is the positional — drop --print: `claude --bg '<task>'`.");
     }
@@ -1215,6 +1255,7 @@ export function parseCliInvocation(argv) {
         'plugin',
         'doctor',
         'import',
+        'auth',
     ].includes(args[0] ?? '');
     if (promptSuggestions &&
         !managementCommand &&
@@ -1385,6 +1426,8 @@ export function parseCliInvocation(argv) {
         ...(worktreeRequested ? { worktreeRequested: true } : {}),
         ...(tmux === undefined ? {} : { tmux }),
         ...(model === undefined ? {} : { model }),
+        ...(provider === undefined ? {} : { provider }),
+        ...(providerProfile === undefined ? {} : { providerProfile }),
         ...(effort === undefined ? {} : { effort }),
         ...(thinking === undefined ? {} : { thinking }),
         ...(maxThinkingTokens === undefined ? {} : { maxThinkingTokens }),
@@ -1402,6 +1445,8 @@ export function parseCliInvocation(argv) {
         mcpClientSecret,
         mcpNoBrowser,
         mcpDebug,
+        ...(authProfile === undefined ? {} : { authProfile }),
+        authDevice,
     };
 }
 function parseUserMessage(value, lineNumber) {

package/dist/cli/provider-auth-command.d.ts

@@ -0,0 +1,32 @@
+import { type ProviderCredentialKey, type ProviderCredentialMetadata, type ProviderCredentialInput, type ProviderCredentialRecord } from '../persistence/provider-credential-vault.js';
+import { deviceLoginWithCodexOAuth, loginWithCodexOAuth } from '../providers/codex-oauth.js';
+export interface ProviderAuthCommandIO {
+    stdout(message: string): void;
+    stderr?(message: string): void;
+    readSecret?(prompt: string, signal?: AbortSignal): Promise<string>;
+}
+export interface ProviderAuthVault {
+    read(key: ProviderCredentialKey): Promise<ProviderCredentialRecord | undefined>;
+    list(): Promise<ProviderCredentialMetadata[]>;
+    modify(key: ProviderCredentialKey, callback: (current: ProviderCredentialRecord | undefined) => ProviderCredentialInput | undefined | Promise<ProviderCredentialInput | undefined>): Promise<ProviderCredentialRecord | undefined>;
+    delete(key: ProviderCredentialKey): Promise<void>;
+}
+export interface ProviderAuthCommandOptions {
+    io: ProviderAuthCommandIO;
+    vault?: ProviderAuthVault;
+    configRoot?: string;
+    cwd?: string;
+    environment?: Readonly<Record<string, string | undefined>>;
+    signal?: AbortSignal;
+    profile?: string;
+    providerProfile?: string;
+    noBrowser?: boolean;
+    json?: boolean;
+    device?: boolean;
+    loginWithCodexOAuth?: typeof loginWithCodexOAuth;
+    deviceLoginWithCodexOAuth?: typeof deviceLoginWithCodexOAuth;
+    assertCodexLoginEnabled?: (profileId: string) => Promise<void>;
+}
+export declare function secretLine(value: string): string;
+export declare function executeProviderAuthCommand(args: readonly string[], options: ProviderAuthCommandOptions): Promise<number>;
+//# sourceMappingURL=provider-auth-command.d.ts.map

package/dist/cli/provider-auth-command.js

@@ -0,0 +1,249 @@
+import { ProviderCredentialVault, } from '../persistence/provider-credential-vault.js';
+import { deviceLoginWithCodexOAuth, loginWithCodexOAuth, } from '../providers/codex-oauth.js';
+import { resolveProviderTarget } from '../providers/provider-settings.js';
+import { resolveDataPlaneRoot } from '../persistence/data-plane.js';
+const IDENTIFIER = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
+const MAX_SECRET_BYTES = 64 * 1024;
+function fail(message) {
+    throw new Error(message);
+}
+function identifier(value, label) {
+    if (!IDENTIFIER.test(value))
+        fail(`${label} must match [A-Za-z0-9][A-Za-z0-9._-]{0,127}`);
+    return value;
+}
+function parse(args, options) {
+    if (args[0] === 'auth')
+        args = args.slice(1);
+    const action = args[0];
+    if (action !== 'status' &&
+        action !== 'set-key' &&
+        action !== 'login' &&
+        action !== 'logout') {
+        fail('auth requires status, set-key, login, or logout');
+    }
+    let provider;
+    let profile;
+    let json = options.json ?? false;
+    let noBrowser = options.noBrowser ?? false;
+    let device = options.device ?? false;
+    for (let index = 1; index < args.length; index += 1) {
+        const value = args[index];
+        if (value === '--json') {
+            if (json)
+                fail('--json may only be specified once');
+            json = true;
+            continue;
+        }
+        if (value === '--device') {
+            if (device)
+                fail('--device may only be specified once');
+            device = true;
+            continue;
+        }
+        if (value === '--no-browser') {
+            if (noBrowser)
+                fail('--no-browser may only be specified once');
+            noBrowser = true;
+            continue;
+        }
+        if (value === '--profile' || value?.startsWith('--profile=')) {
+            if (profile !== undefined)
+                fail('--profile may only be specified once');
+            const selected = value === '--profile' ? args[++index] : value.slice('--profile='.length);
+            if (typeof selected !== 'string' || selected.length === 0)
+                fail('--profile requires a value');
+            profile = identifier(selected, 'profile');
+            continue;
+        }
+        if (value?.startsWith('-'))
+            fail(`Unknown option: ${value}`);
+        if (typeof value !== 'string')
+            fail(`Unexpected operand for auth ${action}`);
+        if (provider !== undefined)
+            fail(`Unexpected operand for auth ${action}: ${value}`);
+        provider = identifier(value, 'provider');
+    }
+    if (options.profile !== undefined &&
+        profile !== undefined &&
+        options.profile !== profile)
+        fail('auth --profile conflicts with the selected profile');
+    if (options.providerProfile !== undefined &&
+        profile !== undefined &&
+        options.providerProfile !== profile)
+        fail('auth --profile conflicts with --provider-profile');
+    if (options.profile !== undefined &&
+        options.providerProfile !== undefined &&
+        options.profile !== options.providerProfile)
+        fail('auth --profile conflicts with --provider-profile');
+    const selectedProfile = profile ?? options.profile ?? options.providerProfile;
+    profile =
+        action === 'status' && selectedProfile === undefined
+            ? undefined
+            : identifier(selectedProfile ?? 'default', 'profile');
+    if (action === 'status' && provider === undefined) {
+        // status accepts zero or one provider operand.
+    }
+    else if (action !== 'status' && provider === undefined) {
+        fail(`auth ${action} requires a provider`);
+    }
+    if (action === 'set-key' && provider === 'openai-codex')
+        fail('auth set-key does not support openai-codex; use auth login');
+    if (action === 'login' && provider !== 'openai-codex')
+        fail('auth login only supports openai-codex');
+    if (action !== 'login' && (device || noBrowser))
+        fail('--device and --no-browser are only valid with auth login');
+    return {
+        action,
+        ...(provider === undefined ? {} : { provider }),
+        ...(profile === undefined ? {} : { profile }),
+        json,
+        device,
+        noBrowser,
+    };
+}
+function defaultVault(options) {
+    const environment = options.environment ?? process.env;
+    const vaultOptions = {
+        configRoot: options.configRoot ?? resolveDataPlaneRoot({ environment }),
+        environment,
+    };
+    return new ProviderCredentialVault(vaultOptions);
+}
+async function assertCodexLoginEnabled(options, profileId) {
+    const environment = options.environment ?? process.env;
+    await resolveProviderTarget({
+        configRoot: options.configRoot ?? resolveDataPlaneRoot({ environment }),
+        cwd: options.cwd ?? process.cwd(),
+        environment,
+        provider: 'openai-codex',
+        profile: profileId,
+        model: 'codex-authentication',
+    });
+}
+function json(io, value) {
+    io.stdout(`${JSON.stringify(value)}\n`);
+}
+function text(io, message) {
+    io.stdout(`${message}\n`);
+}
+function metadata(value) {
+    return {
+        provider: value.key.providerId,
+        profile: value.key.profileId,
+        type: value.type,
+        updatedAt: value.updatedAt,
+        ...(value.expiresAt === undefined
+            ? {}
+            : { expiry: value.expiresAt > Date.now() ? 'valid' : 'expired' }),
+    };
+}
+function sortedMetadata(records, provider, profile) {
+    return records
+        .filter((record) => (provider === undefined || record.key.providerId === provider) &&
+        (profile === undefined || record.key.profileId === profile))
+        .sort((left, right) => {
+        const providerOrder = left.key.providerId.localeCompare(right.key.providerId);
+        return (providerOrder || left.key.profileId.localeCompare(right.key.profileId));
+    })
+        .map(metadata);
+}
+export function secretLine(value) {
+    if (Buffer.byteLength(value, 'utf8') > MAX_SECRET_BYTES)
+        fail('Credential exceeds the 64 KiB limit');
+    const stripped = value.endsWith('\r\n')
+        ? value.slice(0, -2)
+        : value.endsWith('\r') || value.endsWith('\n')
+            ? value.slice(0, -1)
+            : value;
+    if (/[\r\n]/u.test(stripped) || stripped.trim().length === 0)
+        fail('Credential must be exactly one non-blank line');
+    return stripped;
+}
+export async function executeProviderAuthCommand(args, options) {
+    const parsed = parse(args, options);
+    const vault = options.vault ?? defaultVault(options);
+    if (parsed.action === 'status') {
+        const credentials = sortedMetadata(await vault.list(), parsed.provider, parsed.profile);
+        if (parsed.json) {
+            json(options.io, { type: 'provider-auth-status', credentials });
+        }
+        else if (credentials.length === 0) {
+            text(options.io, 'No provider credentials configured.');
+        }
+        else {
+            text(options.io, credentials
+                .map((credential) => `${credential.provider}/${credential.profile}: ${credential.type}${credential.expiry === undefined ? '' : ` (${credential.expiry})`}`)
+                .join('\n'));
+        }
+        return 0;
+    }
+    const provider = parsed.provider;
+    if (provider === undefined)
+        fail(`auth ${parsed.action} requires a provider`);
+    const key = {
+        providerId: provider,
+        profileId: parsed.profile ?? 'default',
+    };
+    if (parsed.action === 'set-key') {
+        if (!options.io.readSecret)
+            fail('auth set-key requires an interactive secret reader');
+        const secret = secretLine(await options.io.readSecret('API key: ', options.signal));
+        await vault.modify(key, () => ({ type: 'api-key', secret }));
+        const result = {
+            provider: key.providerId,
+            profile: key.profileId,
+            type: 'api-key',
+        };
+        if (parsed.json)
+            json(options.io, result);
+        else
+            text(options.io, `Stored api-key credential for ${key.providerId}/${key.profileId}.`);
+        return 0;
+    }
+    if (parsed.action === 'logout') {
+        const existing = await vault.read(key);
+        if (existing !== undefined)
+            await vault.delete(key);
+        const result = {
+            provider: key.providerId,
+            profile: key.profileId,
+            deleted: true,
+        };
+        if (parsed.json)
+            json(options.io, result);
+        else
+            text(options.io, `Logged out ${key.providerId}/${key.profileId}.`);
+        return 0;
+    }
+    await (options.assertCodexLoginEnabled ??
+        ((profileId) => assertCodexLoginEnabled(options, profileId)))(key.profileId);
+    const loginOptions = {
+        profileId: key.profileId,
+        vault: createCodexOAuthVault(vault),
+        ...(options.signal === undefined ? {} : { signal: options.signal }),
+        ...(parsed.noBrowser ? { noBrowser: true } : {}),
+        write: (message) => options.io.stderr?.(message),
+    };
+    const login = parsed.device
+        ? (options.deviceLoginWithCodexOAuth ?? deviceLoginWithCodexOAuth)
+        : (options.loginWithCodexOAuth ?? loginWithCodexOAuth);
+    await login(loginOptions);
+    const result = {
+        provider: key.providerId,
+        profile: key.profileId,
+        type: 'oauth',
+    };
+    if (parsed.json)
+        json(options.io, result);
+    else
+        text(options.io, `Logged in ${key.providerId}/${key.profileId}.`);
+    return 0;
+}
+function createCodexOAuthVault(vault) {
+    return {
+        read: (key) => vault.read(key),
+        modify: (key, callback) => vault.modify(key, async (current) => callback(current)),
+    };
+}
+//# sourceMappingURL=provider-auth-command.js.map

package/dist/cli/workspace-trust-prompt.js

@@ -23,10 +23,10 @@ export async function promptWorkspaceTrust(inventory, io = {}) {
     const output = io.output ?? ((text) => process.stderr.write(text));
     if (io.signal?.aborted)
         return false;
-    output(`Workspace executable resources found for ${safeWorkspaceTrustDisplayField(inventory.canonicalPath)}\n`);
+    output(`Workspace-controlled resources/configuration found for ${safeWorkspaceTrustDisplayField(inventory.canonicalPath)}\n`);
     for (const origin of inventory.origins)
         output(`  ${origin.kind} (${origin.scope}) ${safeWorkspaceTrustDisplayField(origin.path)}: ${safeWorkspaceTrustDisplayField(origin.label)}\n`);
-    output('Trust these workspace executables? [y/N] ');
+    output('Trust these workspace-controlled resources/configuration? [y/N] ');
     const input = io.input ?? process.stdin;
     const iterator = input[Symbol.asyncIterator]();
     const abortedResult = Symbol('workspace-trust-prompt-aborted');

package/dist/cli-runtime.d.ts

@@ -11,7 +11,7 @@ import type { TuiSlashCommand } from './cli/tui/slash-commands.js';
 import { type TuiHookConfiguration } from './cli/tui/hook-settings.js';
 import { type PraxisRuntimeSettings } from './cli/tui/runtime-settings.js';
 import { type ClaudePermissionMode } from './permissions/claude-permission-resolver.js';
-import { type WorkspaceTrustInventory } from './security/workspace-trust.js';
+import { type WorkspaceTrustAssessment, type WorkspaceTrustInventory } from './security/workspace-trust.js';
 import { type ClaudeMcpServerStatus, type ClaudeMcpToolInspection } from './mcp/claude-mcp-tools.js';
 import { authenticateMcpServer } from './mcp/claude-mcp-oauth.js';
 import { servePraxisMcpStdio } from './mcp/praxis-mcp-server.js';
@@ -20,6 +20,7 @@ import { type ClaudeInteractiveToolCallbacks } from './tools/claude-interactive-
 import { type TopLevelAgentSummary } from './application/top-level-agent-manager.js';
 import { launchTmuxWorktree } from './platform/tmux-worktree.js';
 import { type CliControls, type CliRuntimeInfo, type CliElicitationRequest, type CliElicitationResult } from './cli/protocol.js';
+import { executeProviderAuthCommand } from './cli/provider-auth-command.js';
 import { type PluginEvalDependencies } from './plugins/claude-plugin-eval.js';
 import { type SelfUpdateResult } from './maintenance/self-update.js';
 export { parseContextEnvironment, parseProviderEnvironment };
@@ -28,6 +29,7 @@ export interface CliIO {
     stderr(message: string): void;
     isTTY?: boolean;
     readStdinLines?: () => AsyncIterable<string | Uint8Array>;
+    readSecret?: (prompt: string, signal?: AbortSignal) => Promise<string>;
 }
 interface SessionCommands {
     teamLeadOperations?: TeamLeadOperations;
@@ -143,6 +145,8 @@ export interface CliDependencies extends InteractiveServiceFactory {
     }): Promise<SessionCommands>;
     createAutoModeCritic?(options: {
         model?: string;
+        provider?: string;
+        providerProfile?: string;
         dataPlane?: DataPlane;
         configRoot?: string;
         statePath?: string;
@@ -170,6 +174,7 @@ export interface CliDependencies extends InteractiveServiceFactory {
     launchTmux?: typeof launchTmuxWorktree;
     mcpAuthenticate?: typeof authenticateMcpServer;
     mcpServe?: typeof servePraxisMcpStdio;
+    executeProviderAuthCommand?: typeof executeProviderAuthCommand;
     selfUpdate?: (options: {
         operation: 'install' | 'update';
         target?: string;
@@ -177,6 +182,20 @@ export interface CliDependencies extends InteractiveServiceFactory {
         signal?: AbortSignal;
     }) => Promise<SelfUpdateResult>;
 }
+interface ConsoleSecretInput extends AsyncIterable<string | Uint8Array> {
+    readonly isTTY?: boolean;
+    readonly isRaw?: boolean;
+    isPaused(): boolean;
+    setRawMode?(enabled: boolean): unknown;
+    pause(): unknown;
+    resume(): unknown;
+    on(event: 'data', listener: (chunk: Buffer | string) => void): unknown;
+    removeListener(event: 'data', listener: (chunk: Buffer | string) => void): unknown;
+}
+interface ConsoleSecretOutput {
+    write(message: string): unknown;
+}
+export declare function readConsoleSecret(prompt: string, signal?: AbortSignal, input?: ConsoleSecretInput, output?: ConsoleSecretOutput): Promise<string>;
 /**
  * Shared runtime model precedence used by every consumer (provider
  * construction, status/doctor output, and the interactive display):
@@ -194,9 +213,23 @@ export declare function resolveInteractiveRuntimeSettingsLocation(dataPlane: Dat
     statePath: string;
 };
 export declare function resolveUnknownCostSidecarPath(dataPlane: DataPlane, configRoot: string): string;
+export declare function resolveInteractiveProviderStartup(options: {
+    controls: CliControls;
+    configRoot: string;
+    statePath: string;
+    cwd: string;
+    environment?: NodeJS.ProcessEnv;
+    approveWorkspaceTrust?: (assessment: WorkspaceTrustAssessment) => boolean | Promise<boolean>;
+}): Promise<{
+    effectiveModel: string | undefined;
+    trustProjectRequestAvailable: boolean;
+}>;
 export declare function createDefaultDependencies(entrypoint?: string): CliDependencies;
 export declare function createBackgroundWorkerRuntime(workerSink: RuntimeEventSink, dispatch: {
     argv: string[];
 }, createService?: CliDependencies['createService']): Promise<Awaited<ReturnType<CliDependencies['createService']>>>;
+export declare function agentDashboardWorkerArgv(invocation: CliControls & {
+    agent: string | undefined;
+}): string[];
 export declare function run(argv: readonly string[], io?: CliIO, dependencies?: CliDependencies, signal?: AbortSignal): Promise<number>;
 //# sourceMappingURL=cli-runtime.d.ts.map