@dsh-enhanced/coding-subscription-provider 0.1.2 → 0.1.4

package/lib/adapter.js

@@ -1,11 +1,14 @@
 import { resolve } from 'node:path';
-import { LlmAdapter, LlmError, ReasoningEffortId, } from '@deepseek-ai/dsh-llm';
+import { CONTEXT_WINDOW_EXCEEDED_CODE, EMPTY_RESPONSE_CODE, LlmAdapter, LlmError, QUOTA_EXCEEDED_CODE, ReasoningEffortId, } from '@deepseek-ai/dsh-llm';
 import { verifySubscriptionAuth } from './auth.js';
 import { discoverCodexModels, } from './codex-catalog.js';
-import { configForProvider } from './config.js';
+import { CodexCredentialStore } from './codex-direct-auth.js';
+import { runCodexDirectResponses, } from './codex-direct-responses.js';
+import { configForProvider, } from './config.js';
 import { buildPrompt } from './prompt.js';
 import { runCliText } from './process.js';
 import { buildInvocation } from './providers.js';
+import { resolveTrustedSessionCwd, TrustedSessionCwdError } from './session-cwd.js';
 import { discoverClaudeModels, discoverCursorModels, discoverGrokModels, } from './subscription-catalog.js';
 export const routeDefinitions = [
     { route: 'codex-subscription', cli: 'codex', name: 'Codex Subscription (local CLI)', maturity: 'stable' },
@@ -14,6 +17,7 @@ export const routeDefinitions = [
     { route: 'grok-subscription', cli: 'grok', name: 'Grok Subscription (local Grok Build)', maturity: 'beta' },
 ];
 const CATALOG_TTL_MS = 5 * 60_000;
+const CATALOG_STDERR_DIAGNOSTIC = 'model catalog probe wrote to stderr; content withheld';
 const noAutomaticRetry = Object.freeze({
     mode: 'normal',
     maxRetries: 0,
@@ -34,9 +38,15 @@ function abortReason(signal) {
 function cliFailure(definition, command, error) {
     if (error instanceof Error && error.cause === 'abort')
         return error;
+    if (error instanceof TrustedSessionCwdError) {
+        return new LlmError(`${definition.name} requires a live loop-owned session whose canonical cwd matches the configured local workspace`, 'LOCAL_SESSION_CWD_REQUIRED', { cause: error });
+    }
     if (error instanceof Error && error.cause === 'subscription-auth') {
         return new LlmError(`${definition.name} refused the request because a subscription-compatible login could not be verified`, 'SUBSCRIPTION_AUTH_REQUIRED', { cause: error });
     }
+    if (error instanceof Error && error.cause === 'working-directory') {
+        return new LlmError(`${definition.name} refused the configured working directory; set config.cwd to a Git repository (relative paths resolve from the DSH process directory) and restart DSH`, 'CLI_WORKING_DIRECTORY', { cause: error });
+    }
     if (error instanceof Error && error.cause === 'protocol') {
         return new LlmError(`${definition.name} returned an unrecognized or incomplete event stream`, 'CLI_PROTOCOL_ERROR', { cause: error });
     }
@@ -49,8 +59,86 @@ function cliFailure(definition, command, error) {
     }
     return new LlmError(`${definition.name} failed; verify that the official CLI is installed and logged in with the intended subscription`, 'CLI_FAILED', { cause: error });
 }
+export const CODEX_DIRECT_PROVIDER_HTTP_CODE = 'CODEX_DIRECT_PROVIDER_HTTP';
+export const CODEX_DIRECT_PROVIDER_FAILURE_CODE = 'CODEX_DIRECT_PROVIDER_FAILURE';
+export const CODEX_DIRECT_CONTENT_FILTER_CODE = 'CODEX_DIRECT_CONTENT_FILTER';
+export const CODEX_DIRECT_TRANSPORT_ERROR_CODE = 'CODEX_DIRECT_TRANSPORT_ERROR';
+function directFailure(definition, error) {
+    if (error instanceof LlmError)
+        return error;
+    if (error instanceof Error && error.cause === 'abort')
+        return error;
+    if (error instanceof TrustedSessionCwdError) {
+        return new LlmError(`${definition.name} requires a live loop-owned session whose canonical cwd matches the configured local workspace`, 'LOCAL_SESSION_CWD_REQUIRED', { cause: error });
+    }
+    const cause = error instanceof Error ? error.cause : undefined;
+    const status = validHttpStatus(error);
+    if (cause === 'subscription-auth') {
+        return new LlmError('Codex private Responses could not use the local ChatGPT session', 'SUBSCRIPTION_AUTH_REQUIRED', status === undefined ? undefined : { status });
+    }
+    if (cause === 'timeout') {
+        return new LlmError('Codex private Responses request timed out', 'CLI_TIMEOUT');
+    }
+    if (cause === 'protocol') {
+        return new LlmError('Codex private Responses returned an unrecognized or incomplete stream', 'CLI_PROTOCOL_ERROR');
+    }
+    if (cause === 'provider-http') {
+        return new LlmError('Codex private Responses provider request failed', CODEX_DIRECT_PROVIDER_HTTP_CODE, status === undefined ? undefined : { status });
+    }
+    if (cause === 'context-window') {
+        return new LlmError('Codex private Responses exceeded the model context window', CONTEXT_WINDOW_EXCEEDED_CODE);
+    }
+    if (cause === 'quota') {
+        return new LlmError('Codex private Responses account quota was exhausted', QUOTA_EXCEEDED_CODE);
+    }
+    if (cause === 'provider-failure') {
+        return new LlmError('Codex private Responses reported a provider failure', CODEX_DIRECT_PROVIDER_FAILURE_CODE);
+    }
+    if (cause === 'content-filter') {
+        return new LlmError('Codex private Responses output was filtered', CODEX_DIRECT_CONTENT_FILTER_CODE);
+    }
+    if (cause === 'empty-response') {
+        return new LlmError('Codex private Responses returned no visible output', EMPTY_RESPONSE_CODE);
+    }
+    if (cause === 'transport') {
+        return new LlmError('Codex private Responses transport failed', CODEX_DIRECT_TRANSPORT_ERROR_CODE);
+    }
+    return new LlmError('Codex private Responses request failed', 'CODEX_DIRECT_RESPONSES_FAILED', { cause: error });
+}
+function validHttpStatus(error) {
+    if (typeof error !== 'object' || error === null)
+        return undefined;
+    const status = error.status;
+    return typeof status === 'number' && Number.isInteger(status) && status >= 100 && status <= 599
+        ? status
+        : undefined;
+}
+/** Stable code for a request that needs tool calls this text-only route cannot make. */
+export const TOOL_CALLS_UNSUPPORTED_CODE = 'tool_calls_unsupported';
+/**
+ * Refuse a request that supplies tool schemas.
+ *
+ * These routes drive local coding CLIs that only return assistant text; they
+ * cannot emit a `tool-call` block. Silently dropping `options.tools` would let an
+ * unattended automation appear to run while never invoking its allowlisted tools,
+ * so the request fails loudly and names the working alternative instead.
+ */
+function toolCallsUnsupported(definition) {
+    return new LlmError(`${definition.name} is a text-only route and cannot perform tool calls. `
+        + 'Use a provider that emits tool calls (for example @dsh-enhanced/traex-acp-provider) '
+        + 'for agent or automation work that requires tools.', TOOL_CALLS_UNSUPPORTED_CODE);
+}
+/** Report a local prompt bound through DSH's canonical overflow path so compaction can retry it. */
+function preflightFailure(error) {
+    if (error instanceof Error && error.cause === 'prompt-limit') {
+        return new LlmError(error.message, CONTEXT_WINDOW_EXCEEDED_CODE, { cause: error });
+    }
+    return error instanceof Error ? error : new Error('coding subscription provider could not serialize the DSH request');
+}
 /** Classify the original transport error into a stable, credential-free outcome for diagnostics. */
 function outcomeFor(error) {
+    if (error instanceof TrustedSessionCwdError)
+        return 'working-directory';
     const cause = error instanceof Error ? error.cause : undefined;
     if (cause === 'abort')
         return 'aborted';
@@ -58,6 +146,8 @@ function outcomeFor(error) {
         return 'timeout';
     if (cause === 'subscription-auth')
         return 'auth-required';
+    if (cause === 'working-directory')
+        return 'working-directory';
     if (cause === 'protocol')
         return 'protocol';
     if (cause === 'process-exit')
@@ -89,6 +179,17 @@ function reasoningInfo(model) {
         },
     };
 }
+function directReasoningInfo(profile) {
+    return {
+        reasoning: {
+            efforts: profile.directReasoningEfforts.map(effort => ({
+                id: ReasoningEffortId(effort),
+                name: effort,
+            })),
+            defaultEffort: ReasoningEffortId(profile.directDefaultReasoningEffort),
+        },
+    };
+}
 /** Experimental LLM-compatible facade over local, already-authenticated coding agents. */
 export class CodingSubscriptionAdapter extends LlmAdapter {
     config;
@@ -98,12 +199,19 @@ export class CodingSubscriptionAdapter extends LlmAdapter {
     discoverClaudeModels;
     discoverCursorModels;
     discoverGrokModels;
+    runCodexDirect;
+    codexCredentials;
+    getAttachments;
     verifyAuth;
     onDiagnostic;
     onSettled;
+    liveSessions;
+    requestAttestor;
+    now;
     lifecycle = new AbortController();
     codexCatalogCache;
     subscriptionCatalogCache = new Map();
+    catalogRefreshes = new Map();
     constructor(config, dependencies = {}) {
         super();
         this.config = config;
@@ -113,9 +221,23 @@ export class CodingSubscriptionAdapter extends LlmAdapter {
         this.discoverClaudeModels = dependencies.discoverClaudeModels ?? discoverClaudeModels;
         this.discoverCursorModels = dependencies.discoverCursorModels ?? discoverCursorModels;
         this.discoverGrokModels = dependencies.discoverGrokModels ?? discoverGrokModels;
+        this.runCodexDirect = dependencies.runCodexDirect ?? runCodexDirectResponses;
+        this.codexCredentials = dependencies.codexCredentials ?? new CodexCredentialStore();
+        this.getAttachments = dependencies.getAttachments ?? (() => dependencies.attachments);
         this.verifyAuth = dependencies.verifyAuth ?? verifySubscriptionAuth;
         this.onDiagnostic = dependencies.onDiagnostic;
         this.onSettled = dependencies.onSettled;
+        this.liveSessions = dependencies.liveSessions;
+        this.requestAttestor = dependencies.requestAttestor;
+        this.now = dependencies.now ?? Date.now;
+    }
+    trustedCwd(request) {
+        return resolveTrustedSessionCwd({
+            request,
+            configuredCwd: this.cwd,
+            sessions: this.liveSessions,
+            ...(this.requestAttestor === undefined ? {} : { attestor: this.requestAttestor }),
+        });
     }
     reportSettled(context) {
         if (this.onSettled === undefined)
@@ -129,29 +251,44 @@ export class CodingSubscriptionAdapter extends LlmAdapter {
     }
     providerInfo(provider) {
         const definition = definitionFor(provider);
-        return { id: provider, name: definition.name };
+        return {
+            id: provider,
+            name: definition.cli === 'codex' && this.config.codex.transport === 'direct-responses'
+                ? 'Codex Subscription (private Responses, experimental)'
+                : definition.name,
+        };
     }
     providerRetryPolicy(_provider) {
         return noAutomaticRetry;
     }
-    async loadCodexCatalog(signal = this.lifecycle.signal) {
-        if (signal.aborted)
-            throw abortReason(signal);
+    peekCodexCatalog() {
         const cached = this.codexCatalogCache;
-        if (cached !== undefined && cached.expiresAt > Date.now())
+        if (cached !== undefined && cached.expiresAt > this.now())
+            return cached.catalog;
+        this.codexCatalogCache = undefined;
+        return undefined;
+    }
+    peekSubscriptionCatalog(provider) {
+        const cached = this.subscriptionCatalogCache.get(provider);
+        if (cached !== undefined && cached.expiresAt > this.now())
             return cached.catalog;
+        this.subscriptionCatalogCache.delete(provider);
+        return undefined;
+    }
+    /**
+     * Observe the advisory Codex CLI catalog with bounded, prompt-free control-plane I/O.
+     * Authentication is owned by `refreshCatalog`; this method only performs discovery.
+     */
+    async observeCodexCatalog(cwd, signal) {
+        if (signal.aborted)
+            throw abortReason(signal);
+        const cached = this.peekCodexCatalog();
+        if (cached !== undefined)
+            return cached;
         const definition = definitionFor('codex-subscription');
         const profile = this.config.codex;
         try {
-            await this.verifyAuth('codex', {
-                command: profile.command,
-                cwd: this.cwd,
-                timeoutMs: this.config.authProbeTimeoutMs,
-                maxOutputBytes: this.config.maxAuthProbeBytes,
-                extraEnvNames: this.config.extraEnvNames,
-                signal,
-            });
-            const catalog = await this.discoverCodexModels({ command: profile.command, cwd: this.cwd }, {
+            const catalog = await this.discoverCodexModels({ command: profile.command, cwd }, {
                 signal,
                 timeoutMs: this.config.authProbeTimeoutMs,
                 killGraceMs: this.config.killGraceMs,
@@ -159,23 +296,31 @@ export class CodingSubscriptionAdapter extends LlmAdapter {
                 maxOutputBytes: this.config.maxOutputBytes,
                 maxStderrBytes: this.config.maxStderrBytes,
                 extraEnvNames: this.config.extraEnvNames,
-                onDiagnostic: diagnostic => this.onDiagnostic?.(definition.route, diagnostic),
+                onDiagnostic: () => {
+                    try {
+                        this.onDiagnostic?.(definition.route, CATALOG_STDERR_DIAGNOSTIC);
+                    }
+                    catch {
+                        // A diagnostic sink must never affect catalog discovery.
+                    }
+                },
             });
-            this.codexCatalogCache = { catalog, expiresAt: Date.now() + CATALOG_TTL_MS };
+            if (signal.aborted)
+                throw abortReason(signal);
+            this.codexCatalogCache = { catalog, expiresAt: this.now() + CATALOG_TTL_MS };
             return catalog;
         }
         catch (error) {
             this.codexCatalogCache = undefined;
-            throw cliFailure(definition, profile.command, error);
+            throw error;
         }
     }
-    async loadSubscriptionCatalog(provider, signal = this.lifecycle.signal) {
+    async observeSubscriptionCatalog(provider, cwd, signal) {
         if (signal.aborted)
             throw abortReason(signal);
-        const cached = this.subscriptionCatalogCache.get(provider);
-        if (cached !== undefined && cached.expiresAt > Date.now())
-            return cached.catalog;
-        const definition = routeDefinitions.find(candidate => candidate.cli === provider);
+        const cached = this.peekSubscriptionCatalog(provider);
+        if (cached !== undefined)
+            return cached;
         const profile = configForProvider(this.config, provider);
         const discoverer = provider === 'claude'
             ? this.discoverClaudeModels
@@ -183,51 +328,117 @@ export class CodingSubscriptionAdapter extends LlmAdapter {
                 ? this.discoverCursorModels
                 : this.discoverGrokModels;
         try {
+            const catalog = await discoverer({ command: profile.command, cwd }, {
+                signal,
+                timeoutMs: this.config.authProbeTimeoutMs,
+                maxOutputBytes: this.config.maxAuthProbeBytes,
+                extraEnvNames: this.config.extraEnvNames,
+            });
+            if (signal.aborted)
+                throw abortReason(signal);
+            this.subscriptionCatalogCache.set(provider, { catalog, expiresAt: this.now() + CATALOG_TTL_MS });
+            return catalog;
+        }
+        catch (error) {
+            this.subscriptionCatalogCache.delete(provider);
+            throw error;
+        }
+    }
+    observedCatalog(provider) {
+        return provider === 'codex'
+            ? this.peekCodexCatalog()
+            : this.peekSubscriptionCatalog(provider);
+    }
+    observeCatalog(provider, cwd, signal) {
+        return provider === 'codex'
+            ? this.observeCodexCatalog(cwd, signal)
+            : this.observeSubscriptionCatalog(provider, cwd, signal);
+    }
+    /**
+     * Refresh one CLI catalog after the existing subscription-auth gate. Concurrent
+     * list callers share the complete auth + discovery operation, so a cold picker
+     * cannot fan out local probes. Generation never enters or waits on this path.
+     */
+    refreshCatalog(provider, cwd) {
+        const refreshSignal = this.lifecycle.signal;
+        if (refreshSignal.aborted)
+            return Promise.reject(abortReason(refreshSignal));
+        const cached = this.observedCatalog(provider);
+        if (cached !== undefined)
+            return Promise.resolve(cached);
+        const active = this.catalogRefreshes.get(provider);
+        if (active !== undefined)
+            return active;
+        const profile = configForProvider(this.config, provider);
+        let refresh;
+        refresh = (async () => {
             await this.verifyAuth(provider, {
                 command: profile.command,
-                cwd: this.cwd,
+                cwd,
                 timeoutMs: this.config.authProbeTimeoutMs,
                 maxOutputBytes: this.config.maxAuthProbeBytes,
                 extraEnvNames: this.config.extraEnvNames,
-                signal,
+                signal: refreshSignal,
                 ...(provider === 'grok'
                     ? { userVerifiedSubscription: this.config.grok.userVerifiedSubscription }
                     : {}),
             });
-            const catalog = await discoverer({ command: profile.command, cwd: this.cwd }, {
-                signal,
-                timeoutMs: this.config.authProbeTimeoutMs,
-                maxOutputBytes: this.config.maxAuthProbeBytes,
-                extraEnvNames: this.config.extraEnvNames,
-            });
-            this.subscriptionCatalogCache.set(provider, { catalog, expiresAt: Date.now() + CATALOG_TTL_MS });
-            return catalog;
+            if (refreshSignal.aborted)
+                throw abortReason(refreshSignal);
+            return this.observeCatalog(provider, cwd, refreshSignal);
+        })().finally(() => {
+            if (this.catalogRefreshes.get(provider) === refresh)
+                this.catalogRefreshes.delete(provider);
+        });
+        this.catalogRefreshes.set(provider, refresh);
+        return refresh;
+    }
+    reportCatalogRefreshFailure(definition, error) {
+        if (this.lifecycle.signal.aborted)
+            return;
+        const diagnostic = `model catalog refresh failed; outcome=${outcomeFor(error)}; using configured models`;
+        try {
+            this.onDiagnostic?.(definition.route, diagnostic);
         }
-        catch (error) {
-            this.subscriptionCatalogCache.delete(provider);
-            throw cliFailure(definition, profile.command, error);
+        catch {
+            // A diagnostic sink must never turn advisory catalog failure into listModels failure.
         }
     }
     async listModels(provider) {
         const definition = definitionFor(provider);
         const profile = configForProvider(this.config, definition.cli);
-        const catalog = definition.cli === 'codex'
-            ? await this.loadCodexCatalog()
-            : await this.loadSubscriptionCatalog(definition.cli);
-        const defaultModel = catalog.models.find(model => model.id === catalog.defaultModel);
+        const directCodex = definition.cli === 'codex' && this.config.codex.transport === 'direct-responses';
+        let catalog;
+        if (!directCodex && !this.lifecycle.signal.aborted) {
+            try {
+                catalog = await this.refreshCatalog(definition.cli, this.cwd);
+            }
+            catch (error) {
+                this.reportCatalogRefreshFailure(definition, error);
+            }
+        }
+        const attachments = directCodex ? this.getAttachments() : undefined;
+        const inputModalities = directCodex && attachments !== undefined
+            ? ['text', 'image']
+            : ['text'];
+        const defaultModel = catalog?.models.find(model => model.id === catalog.defaultModel);
         const entries = new Map();
         for (const model of profile.models) {
             entries.set(model, {
                 provider,
                 id: model,
-                name: model === 'default'
-                    ? `${definition.name} default${defaultModel === undefined ? '' : ` (${defaultModel.name})`}`
-                    : model,
-                description: `${definition.maturity} local coding-agent delegation; authentication and billing remain in the official CLI`,
-                inputModalities: ['text'],
+                name: directCodex && model === 'default'
+                    ? `Codex Subscription (private Responses) default (${this.config.codex.directModel})`
+                    : model === 'default'
+                        ? `${definition.name} default${defaultModel === undefined ? '' : ` (${defaultModel.name})`}`
+                        : model,
+                description: directCodex
+                    ? 'experimental direct private Codex Responses transport using the local ChatGPT session'
+                    : `${definition.maturity} local coding-agent delegation; authentication and billing remain in the official CLI`,
+                inputModalities,
             });
         }
-        for (const model of catalog.models) {
+        for (const model of catalog?.models ?? []) {
             entries.set(model.id, {
                 provider,
                 id: model.id,
@@ -245,21 +456,25 @@ export class CodingSubscriptionAdapter extends LlmAdapter {
         if (effectiveSignal.aborted)
             throw abortReason(effectiveSignal);
         const definition = definitionFor(provider);
-        const catalog = definition.cli === 'codex'
-            ? await this.loadCodexCatalog(effectiveSignal)
-            : await this.loadSubscriptionCatalog(definition.cli, effectiveSignal);
+        const directCodex = definition.cli === 'codex' && this.config.codex.transport === 'direct-responses';
+        const catalog = directCodex ? undefined : this.observedCatalog(definition.cli);
         const catalogModel = model === 'default'
-            ? catalog.models.find(candidate => candidate.id === catalog.defaultModel)
-            : catalog.models.find(candidate => candidate.id === model);
+            ? catalog?.models.find(candidate => candidate.id === catalog.defaultModel)
+            : catalog?.models.find(candidate => candidate.id === model);
+        const attachments = directCodex ? this.getAttachments() : undefined;
         return {
             provider,
             id: model,
-            name: model === 'default'
-                ? `${definition.name} default${catalogModel === undefined ? '' : ` (${catalogModel.name})`}`
-                : (catalogModel?.name ?? model),
-            description: catalogModel?.description ?? `${definition.maturity} local coding-agent delegation`,
-            inputModalities: ['text'],
-            ...reasoningInfo(catalogModel),
+            name: directCodex && model === 'default'
+                ? `Codex Subscription (private Responses) default (${this.config.codex.directModel})`
+                : model === 'default'
+                    ? `${definition.name} default${catalogModel === undefined ? '' : ` (${catalogModel.name})`}`
+                    : (catalogModel?.name ?? model),
+            description: catalogModel?.description ?? (directCodex
+                ? 'experimental direct private Codex Responses transport using the local ChatGPT session'
+                : `${definition.maturity} local coding-agent delegation`),
+            inputModalities: directCodex && attachments !== undefined ? ['text', 'image'] : ['text'],
+            ...(directCodex ? directReasoningInfo(this.config.codex) : reasoningInfo(catalogModel)),
         };
     }
     async *stream(options) {
@@ -272,7 +487,7 @@ export class CodingSubscriptionAdapter extends LlmAdapter {
         let transportContext;
         // Track the best-known lifecycle facts so a single settled report fires on ANY exit,
         // including a consumer that returns early after block-start or a text delta.
-        let phase = 'auth';
+        let phase = 'preflight';
         let promptSubmissionState = 'not-submitted';
         let outcome = 'aborted';
         let reported = false;
@@ -295,10 +510,99 @@ export class CodingSubscriptionAdapter extends LlmAdapter {
             });
         };
         try {
+            if (signal.aborted)
+                throw abortReason(signal);
+            const directCodex = definition.cli === 'codex' && this.config.codex.transport === 'direct-responses';
+            // Refuse tool work before any subprocess starts: this route cannot emit a
+            // tool call, and a silent drop would look like a successful empty run.
+            if (!directCodex && options.tools !== undefined && options.tools.length > 0) {
+                outcome = 'preflight';
+                throw toolCallsUnsupported(definition);
+            }
+            let cwd;
+            try {
+                cwd = this.trustedCwd(options);
+            }
+            catch (error) {
+                outcome = outcomeFor(error);
+                throw cliFailure(definition, profile.command, error);
+            }
+            if (directCodex) {
+                const timeoutSignal = AbortSignal.timeout(this.config.timeoutMs);
+                const directSignal = AbortSignal.any([signal, timeoutSignal]);
+                try {
+                    // Revalidate immediately before the first credential/file/network seam.
+                    this.trustedCwd(options);
+                    // `maxTokens` is a host-local Agent Loop budget. The private Codex
+                    // request has no max_output_tokens field, so do not hand this hint to
+                    // the direct runner (which deliberately rejects unsupported controls).
+                    const { maxTokens: hostMaxTokens, ...directInput } = options;
+                    void hostMaxTokens;
+                    const directOptions = {
+                        ...directInput,
+                        model: options.model === 'default' ? this.config.codex.directModel : options.model,
+                        signal: directSignal,
+                    };
+                    const attachments = this.getAttachments();
+                    const chunks = this.runCodexDirect(directOptions, {
+                        request: (body, requestSignal) => {
+                            phase = 'stream';
+                            promptSubmissionState = 'unknown';
+                            return this.codexCredentials.requestResponses(body, requestSignal);
+                        },
+                        maxRequestBytes: this.config.codex.maxRequestBytes,
+                        maxRequestImageBytes: this.config.codex.maxRequestImageBytes,
+                        ...(attachments === undefined ? {} : { attachments }),
+                    });
+                    for await (const chunk of chunks) {
+                        if (chunk.type === 'text-delta' && chunk.text.length > 0)
+                            assistantTextForwarded = true;
+                        yield chunk;
+                    }
+                    outcome = 'ok';
+                    return;
+                }
+                catch (error) {
+                    if (signal.aborted) {
+                        outcome = 'aborted';
+                        throw abortReason(signal);
+                    }
+                    if (error instanceof Error && error.cause === 'prompt-limit') {
+                        phase = 'preflight';
+                        promptSubmissionState = 'not-submitted';
+                        outcome = 'preflight';
+                        throw preflightFailure(error);
+                    }
+                    const failure = timeoutSignal.aborted && !signal.aborted
+                        ? new Error('Codex direct Responses request timed out', { cause: 'timeout' })
+                        : error;
+                    outcome = outcomeFor(failure);
+                    throw directFailure(definition, failure);
+                }
+            }
+            // Build and bound the argv locally before any auth probe or generation subprocess starts.
+            let invocation;
+            try {
+                invocation = buildInvocation(definition.cli, {
+                    cwd,
+                    prompt: buildPrompt(options, this.config.maxPromptBytes),
+                    model: options.model,
+                    ...(definition.cli !== 'cursor' && options.reasoningEffort !== undefined
+                        ? { reasoningEffort: String(options.reasoningEffort) }
+                        : {}),
+                    maxTurns: profile.maxTurns,
+                    command: profile.command,
+                });
+            }
+            catch (error) {
+                outcome = 'preflight';
+                throw preflightFailure(error);
+            }
+            phase = 'auth';
             try {
                 await this.verifyAuth(definition.cli, {
                     command: profile.command,
-                    cwd: this.cwd,
+                    cwd,
                     timeoutMs: this.config.authProbeTimeoutMs,
                     maxOutputBytes: this.config.maxAuthProbeBytes,
                     extraEnvNames: this.config.extraEnvNames,
@@ -317,24 +621,16 @@ export class CodingSubscriptionAdapter extends LlmAdapter {
                 outcome = outcomeFor(error);
                 throw cliFailure(definition, profile.command, error);
             }
-            // Preflight prompt serialization runs before spawn; a failure here is provably not-submitted.
+            // Revalidate the authority boundary after auth so a stale/replaced session
+            // cannot reach the generation process. Catalog discovery belongs exclusively
+            // to listModels and never delays a generation request.
             phase = 'preflight';
-            let invocation;
             try {
-                invocation = buildInvocation(definition.cli, {
-                    cwd: this.cwd,
-                    prompt: buildPrompt(options, this.config.maxPromptBytes),
-                    model: options.model,
-                    ...(definition.cli !== 'cursor' && options.reasoningEffort !== undefined
-                        ? { reasoningEffort: String(options.reasoningEffort) }
-                        : {}),
-                    maxTurns: profile.maxTurns,
-                    command: profile.command,
-                });
+                cwd = this.trustedCwd(options);
             }
             catch (error) {
-                outcome = 'preflight';
-                throw error;
+                outcome = outcomeFor(error);
+                throw cliFailure(definition, profile.command, error);
             }
             const runnerOptions = {
                 timeoutMs: this.config.timeoutMs,
@@ -343,7 +639,7 @@ export class CodingSubscriptionAdapter extends LlmAdapter {
                 maxOutputBytes: this.config.maxOutputBytes,
                 maxStderrBytes: this.config.maxStderrBytes,
                 extraEnvNames: this.config.extraEnvNames,
-                onDiagnostic: diagnostic => this.onDiagnostic?.(definition.route, diagnostic),
+                onDiagnostic: diagnostic => this.onDiagnostic?.(definition.route, redactDiagnostic(diagnostic)),
                 onSettled: context => { transportContext = context; },
                 signal,
             };
@@ -357,6 +653,7 @@ export class CodingSubscriptionAdapter extends LlmAdapter {
                 // Calling an injected runner may itself perform work or throw synchronously, so
                 // stop claiming not-submitted immediately before control crosses that boundary.
                 promptSubmissionState = 'unknown';
+                invocation = { ...invocation, cwd: this.trustedCwd(options) };
                 const deltas = this.runText(invocation, runnerOptions);
                 for await (const delta of deltas) {
                     if (delta.length === 0)
@@ -380,11 +677,12 @@ export class CodingSubscriptionAdapter extends LlmAdapter {
     }
     /** Abort every active/future subprocess when the owning Cordis fiber unloads. */
     shutdown() {
-        this.codexCatalogCache = undefined;
-        this.subscriptionCatalogCache.clear();
         if (!this.lifecycle.signal.aborted) {
             this.lifecycle.abort(new Error('coding subscription provider unloaded', { cause: 'abort' }));
         }
+        this.codexCatalogCache = undefined;
+        this.subscriptionCatalogCache.clear();
+        this.catalogRefreshes.clear();
     }
 }
 export function enabledRoutes(config) {