@wix/pathgrade 1.0.17 → 1.0.19

package/dist/agents/codex-app-server/item-projection.js

@@ -0,0 +1,135 @@
+import { buildSummary, extractSkillNameFromPath, inferCodexExecAction, } from '../../tool-events.js';
+import { sanitizeToolEventResult } from '../../tool-event-results.js';
+import { attachOriginalMcpInput } from '../../sdk/mcp-event-input.js';
+export function projectItemIntoTurn(item, turn, sensitiveValues, timing = {}) {
+    if (item.type === 'agentMessage') {
+        const message = item;
+        if (message.text)
+            turn.assistantMessageParts.push(message.text);
+        return;
+    }
+    if (item.type === 'commandExecution') {
+        projectCommand(item, turn, sensitiveValues, timing);
+        return;
+    }
+    if (item.type === 'fileChange') {
+        const changes = item.changes;
+        for (const change of changes ?? []) {
+            turn.nonAskToolEvents.push({
+                action: 'edit_file', provider: 'codex', providerToolName: 'fileChange',
+                turnNumber: turn.turnNumber, arguments: { file_path: change.path },
+                summary: `edit_file: ${change.path}`, confidence: 'high',
+                rawSnippet: JSON.stringify(change),
+            });
+        }
+        return;
+    }
+    if (item.type === 'mcpToolCall') {
+        projectMcpCall(item, turn, sensitiveValues, timing);
+    }
+}
+function projectCommand(cmd, turn, sensitiveValues, timing) {
+    const action = inferCodexExecAction(cmd.command);
+    const skillPath = extractSkillPathFromText(cmd.command);
+    const args = { command: cmd.command, ...(skillPath ? { path: skillPath } : {}) };
+    const exitCode = finiteNumber(cmd.exitCode);
+    const failed = cmd.status === 'failed' || cmd.status === 'declined'
+        || (exitCode !== undefined && exitCode !== 0);
+    const status = failed ? 'error' : cmd.status === 'completed' ? 'completed' : 'incomplete';
+    const timingFields = projectToolTiming(timing, finiteNumber(cmd.durationMs));
+    turn.nonAskToolEvents.push({
+        action, provider: 'codex', providerToolName: 'commandExecution', toolUseId: cmd.id,
+        turnNumber: turn.turnNumber, arguments: args, status, ...timingFields,
+        ...(typeof cmd.aggregatedOutput === 'string' || exitCode !== undefined ? {
+            result: sanitizeToolEventResult({
+                ...(typeof cmd.aggregatedOutput === 'string' ? { content: cmd.aggregatedOutput } : {}),
+                ...(exitCode !== undefined ? { exitCode } : {}),
+            }, sensitiveValues),
+        } : {}),
+        summary: buildSummary(action, 'commandExecution', args), confidence: 'high',
+        rawSnippet: JSON.stringify({
+            type: cmd.type, id: cmd.id, command: cmd.command, status: cmd.status,
+            cwd: cmd.cwd, commandActions: cmd.commandActions,
+        }),
+    });
+    const recordedSkills = new Set();
+    for (const commandAction of cmd.commandActions ?? []) {
+        const skillName = extractCommandActionSkillName(commandAction) ?? extractSkillNameFromText(cmd.command);
+        if (!skillName || recordedSkills.has(skillName))
+            continue;
+        recordedSkills.add(skillName);
+        turn.nonAskToolEvents.push({
+            action: 'use_skill', provider: 'codex',
+            providerToolName: `commandExecution.commandActions.${commandAction.type ?? 'unknown'}`,
+            turnNumber: turn.turnNumber, arguments: { path: commandAction.path, name: commandAction.name },
+            summary: `use_skill ${skillName}`, confidence: 'high', rawSnippet: JSON.stringify(commandAction), skillName,
+        });
+    }
+}
+function projectMcpCall(call, turn, sensitiveValues, timing) {
+    if (turn.nonAskToolEvents.some((event) => event.action === 'mcp_tool_call'
+        && event.toolUseId === call.id && event.mcp?.invocation === 'not_invoked'))
+        return;
+    const args = recordFromUnknown(call.arguments);
+    const providerToolName = `${call.server}.${call.tool}`;
+    const error = typeof call.error?.message === 'string' ? call.error.message : undefined;
+    const status = call.status === 'completed' && error === undefined
+        ? 'completed' : call.status === 'failed' || error !== undefined ? 'error' : 'incomplete';
+    const resultContent = call.result === undefined ? undefined : JSON.stringify(call.result);
+    turn.nonAskToolEvents.push(attachOriginalMcpInput({
+        action: 'mcp_tool_call', provider: 'codex', providerToolName, toolUseId: call.id,
+        turnNumber: turn.turnNumber, status, ...projectToolTiming(timing, finiteNumber(call.durationMs)),
+        arguments: { ...args, server: call.server, tool: call.tool, status: call.status ?? 'unknown' },
+        summary: `MCP tool ${providerToolName} ${call.status ?? 'unknown'}`, confidence: 'high',
+        rawSnippet: JSON.stringify({
+            type: call.type, id: call.id, server: call.server, tool: call.tool,
+            status: call.status, arguments: call.arguments, durationMs: call.durationMs,
+        }),
+        ...(resultContent !== undefined || error !== undefined ? {
+            result: sanitizeToolEventResult({
+                ...(resultContent !== undefined ? { content: resultContent } : {}),
+                ...(error !== undefined ? { content: error } : {}),
+            }, sensitiveValues),
+        } : {}),
+    }, args));
+}
+/** Provider duration is authoritative; observed monotonic duration is the fallback. */
+export function projectToolTiming(timing, providerDurationMs) {
+    const startedAtMs = finiteTimestamp(timing.startedAtWallMs);
+    const completedAtMs = finiteTimestamp(timing.completedAtWallMs);
+    const observedDurationMs = finiteTimestamp(timing.observedDurationMs);
+    const validProviderDurationMs = finiteTimestamp(providerDurationMs);
+    return {
+        ...(startedAtMs !== undefined ? { startedAt: new Date(startedAtMs).toISOString() } : {}),
+        ...(completedAtMs !== undefined ? { completedAt: new Date(completedAtMs).toISOString() } : {}),
+        ...(validProviderDurationMs !== undefined
+            ? { durationMs: validProviderDurationMs }
+            : observedDurationMs !== undefined ? { durationMs: observedDurationMs } : {}),
+    };
+}
+function extractCommandActionSkillName(action) {
+    if (typeof action.path === 'string') {
+        const direct = extractSkillNameFromPath(action.path);
+        if (direct)
+            return direct;
+        const embedded = extractSkillNameFromText(action.path);
+        if (embedded)
+            return embedded;
+    }
+    return typeof action.command === 'string' ? extractSkillNameFromText(action.command) : undefined;
+}
+function extractSkillNameFromText(value) {
+    return value?.match(/(?:^|[/\s"'])\.(?:agents|claude)\/skills\/([^/\s"']+)\/SKILL\.md(?:$|[\s"'])/)?.[1];
+}
+function extractSkillPathFromText(value) {
+    return value?.match(/(?:^|[\s"'])(?<path>(?:\/|\.{1,2}\/)?[^\s"']*(?:\.agents|\.claude)\/skills\/[^/\s"']+\/SKILL\.md)(?:$|[\s"'])/)?.groups?.path;
+}
+function recordFromUnknown(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function finiteTimestamp(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+function finiteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}

package/dist/agents/codex-app-server/managed-auth.d.ts

@@ -0,0 +1,12 @@
+import { createDefaultCodexAuthBroker, type CodexAuthBroker } from '../../openai-oauth/codex-auth-broker.js';
+import type { AppServerTransport } from './transport.js';
+export interface CodexManagedAuth {
+    login(transport: AppServerTransport): Promise<void>;
+    respondToRefresh(requestId: number | string, transport: AppServerTransport, failTurn: (message: string) => void): void;
+}
+export declare function createCodexManagedAuth(input: {
+    enabled: boolean;
+    broker?: CodexAuthBroker;
+    codexHome?: string;
+    createBroker?: typeof createDefaultCodexAuthBroker;
+}): CodexManagedAuth;

package/dist/agents/codex-app-server/managed-auth.js

@@ -0,0 +1,53 @@
+import { createDefaultCodexAuthBroker, } from '../../openai-oauth/codex-auth-broker.js';
+const UNSUPPORTED_MESSAGE = 'codex app-server requires OPENAI_API_KEY for pathgrade and honors OPENAI_BASE_URL when set; ChatGPT/cached auth unsupported under transport=app-server';
+export function createCodexManagedAuth(input) {
+    let brokerPromise;
+    const broker = () => brokerPromise ??= input.broker
+        ? Promise.resolve(input.broker)
+        : (input.createBroker ?? createDefaultCodexAuthBroker)({
+            env: {
+                ...process.env,
+                ...(input.codexHome ? { CODEX_HOME: input.codexHome } : {}),
+            },
+        });
+    let refreshPromise;
+    const refresh = () => refreshPromise ??= broker()
+        .then((value) => value.acquireAccessSession({ refresh: true }))
+        .finally(() => { refreshPromise = undefined; });
+    return {
+        async login(transport) {
+            if (!input.enabled)
+                return;
+            try {
+                const session = await (await broker()).acquireAccessSession({ refresh: false });
+                await transport.sendRequest('account/login/start', {
+                    type: 'chatgptAuthTokens',
+                    accessToken: session.accessToken,
+                    chatgptAccountId: session.accountId,
+                    chatgptPlanType: null,
+                });
+            }
+            catch {
+                throw new Error('Codex-managed ChatGPT authentication unavailable');
+            }
+        },
+        respondToRefresh(requestId, transport, failTurn) {
+            if (!input.enabled) {
+                transport.sendErrorResponse(requestId, -32001, UNSUPPORTED_MESSAGE);
+                failTurn(UNSUPPORTED_MESSAGE);
+                return;
+            }
+            void refresh()
+                .then((session) => transport.sendResponse(requestId, {
+                accessToken: session.accessToken,
+                chatgptAccountId: session.accountId,
+                chatgptPlanType: null,
+            }))
+                .catch(() => {
+                const message = 'Codex-managed ChatGPT authentication refresh failed';
+                transport.sendErrorResponse(requestId, -32001, message);
+                failTurn(message);
+            });
+        },
+    };
+}

package/dist/agents/codex-app-server/transport.d.ts

@@ -44,6 +44,8 @@ export interface SpawnAppServerTransportInput {
      * Exposed for tests; defaults to 2s for production spawns.
      */
     killGracePeriodMs?: number;
+    /** Disable stderr logging for secret-bearing control-plane uses. */
+    logStderrOnExit?: boolean;
 }
 export declare function buildAppServerSpawnArgs(args?: readonly string[], env?: NodeJS.ProcessEnv): string[];
 /**

package/dist/agents/codex-app-server/transport.js

@@ -73,6 +73,12 @@ function createNdjsonTransportInternal(cfg) {
             return;
         output.write(JSON.stringify(obj) + '\n');
     };
+    const rejectPending = () => {
+        for (const resolver of pendingRequests.values()) {
+            resolver({ error: { code: -32_000, message: 'AppServerTransport closed' } });
+        }
+        pendingRequests.clear();
+    };
     return {
         sendRequest(method, params) {
             if (closed)
@@ -121,9 +127,10 @@ function createNdjsonTransportInternal(cfg) {
                 return;
             closed = true;
             rl.close();
-            pendingRequests.clear();
+            rejectPending();
         },
         notifyClose(info) {
+            rejectPending();
             for (const h of closeHandlers) {
                 try {
                     h(info);
@@ -234,15 +241,35 @@ export function spawnAppServerTransport(cfg = {}) {
         input: child.stdout,
         pid: child.pid,
     });
+    let spawnFailed = false;
+    child.on('error', () => {
+        spawnFailed = true;
+        transport.notifyClose({ exitCode: null, signal: null, pid: child.pid });
+    });
     child.on('exit', (exitCode, signal) => {
-        if (stderrBuf.trim().length > 0) {
+        if (cfg.logStderrOnExit !== false && stderrBuf.trim().length > 0) {
             console.error(`[codex app-server pid=${child.pid}] exited with code=${exitCode} signal=${signal}. stderr:\n${stderrBuf}`);
         }
         transport.notifyClose({ exitCode, signal, pid: child.pid });
     });
+    const sessionChild = {
+        pid: child.pid,
+        kill: (signal) => child.kill(signal),
+        once: (_event, listener) => {
+            const finish = () => {
+                child.off('exit', finish);
+                child.off('error', finish);
+                listener();
+            };
+            child.once('exit', finish);
+            child.once('error', finish);
+        },
+        get exitCode() { return spawnFailed ? -1 : child.exitCode; },
+        get signalCode() { return child.signalCode; },
+    };
     return createAppServerSessionHandle({
         transport,
-        child,
+        child: sessionChild,
         ...(cfg.killGracePeriodMs !== undefined ? { killGracePeriodMs: cfg.killGracePeriodMs } : {}),
     });
 }

package/dist/agents/opencode/host-safety.d.ts

@@ -0,0 +1,3 @@
+export declare function sha256File(filename: string): Promise<string>;
+export declare function managedOpenCodeConfigPaths(platform?: NodeJS.Platform, username?: string): string[];
+export declare function assertCleanManagedOpenCodeHost(candidates?: string[]): Promise<void>;

package/dist/agents/opencode/host-safety.js

@@ -0,0 +1,30 @@
+import * as os from 'node:os';
+import fs from 'fs-extra';
+import { createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+export function sha256File(filename) {
+    return new Promise((resolve, reject) => {
+        const hash = createHash('sha256');
+        const stream = createReadStream(filename);
+        stream.on('error', reject);
+        stream.on('data', (chunk) => hash.update(chunk));
+        stream.on('end', () => resolve(hash.digest('hex')));
+    });
+}
+export function managedOpenCodeConfigPaths(platform = process.platform, username = os.userInfo().username) {
+    return platform === 'linux'
+        ? ['/etc/opencode/opencode.json', '/etc/opencode/opencode.jsonc']
+        : [
+            '/Library/Application Support/opencode/opencode.json',
+            '/Library/Application Support/opencode/opencode.jsonc',
+            `/Library/Managed Preferences/${username}/ai.opencode.managed.plist`,
+            '/Library/Managed Preferences/ai.opencode.managed.plist',
+        ];
+}
+export async function assertCleanManagedOpenCodeHost(candidates = managedOpenCodeConfigPaths()) {
+    for (const candidate of candidates) {
+        if (await fs.pathExists(candidate)) {
+            throw new Error(`OpenCode managed host configuration is not supported: ${candidate}`);
+        }
+    }
+}

package/dist/agents/opencode.d.ts

@@ -1,4 +1,5 @@
 import { BaseAgent, type AgentCommandRunner, type AgentSession, type AgentSessionOptions, type AgentTurnResult, type EnvironmentHandle } from '../types.js';
+export { assertCleanManagedOpenCodeHost, managedOpenCodeConfigPaths } from './opencode/host-safety.js';
 interface SpawnResult {
     stdout: string;
     exitCode: number | null;
@@ -18,10 +19,7 @@ interface ParsedOpenCodeTurn {
     result: AgentTurnResult;
     sessionId: string;
 }
-export declare function parseOpenCodeOutput(stdout: string, processResult: Pick<SpawnResult, 'exitCode' | 'overflow' | 'aborted'>, mcpToolNames: ReadonlySet<string>): ParsedOpenCodeTurn;
-export declare function managedOpenCodeConfigPaths(platform?: NodeJS.Platform, username?: string): string[];
-export declare function assertCleanManagedOpenCodeHost(candidates?: string[]): Promise<void>;
+export declare function parseOpenCodeOutput(stdout: string, processResult: Pick<SpawnResult, 'exitCode' | 'overflow' | 'aborted'>, mcpToolNames: ReadonlySet<string>, sensitiveValues?: readonly string[]): ParsedOpenCodeTurn;
 export declare class OpenCodeAgent extends BaseAgent {
     createSession(runtime: EnvironmentHandle, _runCommand: AgentCommandRunner, options?: AgentSessionOptions): Promise<AgentSession>;
 }
-export {};

package/dist/agents/opencode.js

@@ -1,16 +1,19 @@
 import { spawn } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import { createReadStream } from 'node:fs';
-import * as os from 'node:os';
 import * as path from 'node:path';
 import fs from 'fs-extra';
 import { BaseAgent, getRuntimeEnv, getWorkspacePath, } from '../types.js';
 import { buildSummary, enrichSkillEvents } from '../tool-events.js';
+import { collectSensitiveEnvValues, sanitizePersistenceValue, sanitizeToolEventResult, } from '../tool-event-results.js';
 import { readStagedMcpServers } from '../providers/mcp-config.js';
 import { removeSandboxRoot } from '../providers/sandbox-lifecycle.js';
+import { attachTurnResultSensitiveValues } from '../sdk/turn-result-secrets.js';
+import { attachOriginalMcpInput } from '../sdk/mcp-event-input.js';
+import { attachToolEventSensitiveValues } from '../sdk/tool-event-secrets.js';
 import { currentOpenCodePlatformKey, OPENCODE_RUNTIME_LOCK, } from './opencode/contract.js';
 import { OpenCodeRuntimePolicy, OPENCODE_PERMISSION } from './opencode/runtime-policy.js';
 import { killOpenCodeProcessGroup, registerOpenCodeProcessGroup, unregisterOpenCodeProcessGroup, } from './opencode/process-groups.js';
+import { assertCleanManagedOpenCodeHost, sha256File } from './opencode/host-safety.js';
+export { assertCleanManagedOpenCodeHost, managedOpenCodeConfigPaths } from './opencode/host-safety.js';
 const OUTPUT_CAP_BYTES = 16 * 1024 * 1024;
 const NATIVE_TOOL_ACTIONS = {
     bash: 'run_shell',
@@ -147,7 +150,7 @@ function sanitizedProviderError(event) {
     const retryable = typeof data.isRetryable === 'boolean' ? ` retryable=${data.isRetryable}` : '';
     return new Error(`OpenCode provider error${status}${retryable}`);
 }
-export function parseOpenCodeOutput(stdout, processResult, mcpToolNames) {
+export function parseOpenCodeOutput(stdout, processResult, mcpToolNames, sensitiveValues = []) {
     if (processResult.overflow)
         throw new Error('OpenCode output exceeded the 16 MiB limit');
     if (processResult.aborted)
@@ -216,28 +219,52 @@ export function parseOpenCodeOutput(stdout, processResult, mcpToolNames) {
             if (state.status !== 'completed' && state.status !== 'error') {
                 throw new Error(`OpenCode protocol error: incomplete tool ${tool}`);
             }
+            const projectedStatus = state.status;
             const input = state.input === undefined ? undefined : record(state.input, 'tool_use state.input');
             const time = state.time === undefined ? undefined : record(state.time, 'tool_use state.time');
             const startedAtMs = time === undefined ? undefined : finiteNumber(time.start, 'tool_use state.time.start');
             const completedAtMs = time === undefined ? undefined : finiteNumber(time.end, 'tool_use state.time.end');
+            const callId = typeof part.callID === 'string' ? part.callID : undefined;
+            const metadata = state.metadata === undefined ? undefined : record(state.metadata, 'tool_use state.metadata');
+            const output = state.status === 'completed' && typeof state.output === 'string' ? state.output : undefined;
+            const error = state.status === 'error' && typeof state.error === 'string' ? state.error : undefined;
+            const exitCode = metadata && typeof metadata.exit === 'number' && Number.isFinite(metadata.exit)
+                ? metadata.exit
+                : undefined;
+            const status = projectedStatus === 'completed' && exitCode !== undefined && exitCode !== 0
+                ? 'error'
+                : projectedStatus;
             const action = mcpToolNames.has(tool)
                 ? 'mcp_tool_call'
                 : NATIVE_TOOL_ACTIONS[tool] ?? 'unknown';
-            toolEvents.push({
+            const toolEvent = {
                 action,
                 provider: 'opencode',
                 providerToolName: tool,
+                status,
+                ...(callId ? { toolUseId: callId } : {}),
                 ...(input ? { arguments: input } : {}),
                 ...(startedAtMs !== undefined ? { startedAt: new Date(startedAtMs).toISOString() } : {}),
                 ...(completedAtMs !== undefined ? { completedAt: new Date(completedAtMs).toISOString() } : {}),
                 ...(startedAtMs !== undefined && completedAtMs !== undefined
                     ? { durationMs: Math.max(0, completedAtMs - startedAtMs) }
                     : {}),
+                ...(output !== undefined || error !== undefined || exitCode !== undefined || metadata?.truncated === true
+                    ? { result: sanitizeToolEventResult({
+                            ...(output !== undefined ? { content: output } : {}),
+                            ...(error !== undefined ? { content: error } : {}),
+                            ...(exitCode !== undefined ? { exitCode } : {}),
+                            ...(metadata?.truncated === true ? { truncated: true } : {}),
+                        }, sensitiveValues) }
+                    : {}),
                 summary: buildSummary(action, tool, input),
                 confidence: action === 'unknown' ? 'low' : 'high',
                 rawSnippet: JSON.stringify({ tool, status: state.status, input }).slice(0, 2_000),
-            });
-            sanitizedTrace.push({ type, tool, status: state.status, input });
+            };
+            toolEvents.push(action === 'mcp_tool_call' && input
+                ? attachOriginalMcpInput(toolEvent, input)
+                : toolEvent);
+            sanitizedTrace.push({ type, tool, status, input });
             continue;
         }
         if (type === 'step_finish') {
@@ -274,34 +301,28 @@ export function parseOpenCodeOutput(stdout, processResult, mcpToolNames) {
     if (stepFinishCount === 0)
         throw new Error('OpenCode protocol error: missing step_finish');
     const assistantMessage = textParts.join('');
-    const traceOutput = sanitizedTrace.map((event) => JSON.stringify(event)).join('\n');
+    const traceOutput = sanitizePersistenceValue(sanitizedTrace, sensitiveValues)
+        .map((event) => JSON.stringify(event))
+        .join('\n');
     return {
         sessionId,
-        result: {
+        result: attachTurnResultSensitiveValues({
             rawOutput: traceOutput,
             traceOutput,
             assistantMessage,
             visibleAssistantMessage: assistantMessage,
             visibleAssistantMessageSource: 'assistant_message',
             exitCode: 0,
-            toolEvents: enrichSkillEvents(toolEvents),
+            toolEvents: enrichSkillEvents(toolEvents)
+                .map((event) => attachToolEventSensitiveValues(event, sensitiveValues)),
             inputTokens,
             outputTokens,
             cacheCreationInputTokens,
             cacheReadInputTokens,
             costUsd,
-        },
+        }, sensitiveValues),
     };
 }
-function sha256File(filename) {
-    return new Promise((resolve, reject) => {
-        const hash = createHash('sha256');
-        const stream = createReadStream(filename);
-        stream.on('error', reject);
-        stream.on('data', (chunk) => hash.update(chunk));
-        stream.on('end', () => resolve(hash.digest('hex')));
-    });
-}
 async function assertNoProjectConfig(workspacePath) {
     for (const name of ['opencode.json', 'opencode.jsonc', '.opencode']) {
         if (await fs.pathExists(path.join(workspacePath, name))) {
@@ -309,23 +330,6 @@ async function assertNoProjectConfig(workspacePath) {
         }
     }
 }
-export function managedOpenCodeConfigPaths(platform = process.platform, username = os.userInfo().username) {
-    return platform === 'linux'
-        ? ['/etc/opencode/opencode.json', '/etc/opencode/opencode.jsonc']
-        : [
-            '/Library/Application Support/opencode/opencode.json',
-            '/Library/Application Support/opencode/opencode.jsonc',
-            `/Library/Managed Preferences/${username}/ai.opencode.managed.plist`,
-            '/Library/Managed Preferences/ai.opencode.managed.plist',
-        ];
-}
-export async function assertCleanManagedOpenCodeHost(candidates = managedOpenCodeConfigPaths()) {
-    for (const candidate of candidates) {
-        if (await fs.pathExists(candidate)) {
-            throw new Error(`OpenCode managed host configuration is not supported: ${candidate}`);
-        }
-    }
-}
 async function projectMcpConfig(workspacePath, mcpConfigPath) {
     if (!mcpConfigPath)
         return {};
@@ -355,6 +359,7 @@ class OpenCodeSession {
     getAbortSignal;
     getRemainingMs;
     requestedModel;
+    sensitiveValues;
     xdgDirs;
     runtimePolicy;
     resolvedExecutable;
@@ -374,6 +379,10 @@ class OpenCodeSession {
         this.getAbortSignal = options.getAbortSignal ?? (() => options.abortSignal);
         this.getRemainingMs = options.getRemainingMs ?? (() => 0);
         this.requestedModel = options.model;
+        this.sensitiveValues = [...new Set([
+                ...collectSensitiveEnvValues(this.runtimeEnv),
+                ...(options.sensitiveValues ?? []),
+            ])];
         const home = this.runtimeEnv.HOME;
         if (!home)
             throw new Error('OpenCode requires a managed HOME');
@@ -436,7 +445,7 @@ class OpenCodeSession {
             finally {
                 await this.runtimePolicy.afterTurn();
             }
-            const parsed = parseOpenCodeOutput(processResult.stdout, processResult, this.mcpToolNames);
+            const parsed = parseOpenCodeOutput(processResult.stdout, processResult, this.mcpToolNames, this.sensitiveValues);
             if (this.sessionId && parsed.sessionId !== this.sessionId) {
                 throw new Error('OpenCode protocol error: resumed session ID changed');
             }

package/dist/openai-oauth/chatgpt-oauth-llm.d.ts

@@ -0,0 +1,25 @@
+import type { ToolCapableLLMPort } from '../utils/llm-types.js';
+import { type CodexAuthBroker } from './codex-auth-broker.js';
+export interface ChatGptOAuthJudgeOptions {
+    model: string;
+    reasoningEffort: 'low' | 'medium' | 'high';
+    requestTimeoutMs?: number;
+}
+export type ChatGptOAuthJudgeErrorCode = 'OAUTH_CONFIG_INVALID' | 'OAUTH_DEPENDENCY_UNAVAILABLE' | 'OAUTH_CODEX_UNAVAILABLE' | 'OAUTH_CODEX_LOGIN_REQUIRED' | 'OAUTH_AUTH_TIMEOUT' | 'OAUTH_MODEL_MISMATCH' | 'OAUTH_MODEL_UNAVAILABLE' | 'OAUTH_REQUEST_TIMEOUT' | 'OAUTH_UPSTREAM_RATE_LIMITED' | 'OAUTH_UPSTREAM_FAILED' | 'OAUTH_PROTOCOL_RESPONSE_INVALID';
+export declare class ChatGptOAuthJudgeError extends Error {
+    readonly code: ChatGptOAuthJudgeErrorCode;
+    constructor(code: ChatGptOAuthJudgeErrorCode, message?: string);
+}
+type CoreModule = typeof import('@openai-oauth/core');
+export interface ChatGptOAuthJudgeDependencies {
+    broker?: CodexAuthBroker;
+    fetch?: typeof globalThis.fetch;
+    loadCore?: () => Promise<CoreModule>;
+    codexBinary?: string;
+    codexEnv?: NodeJS.ProcessEnv;
+    authTimeoutMs?: number;
+}
+export declare function createChatGptOAuthJudgeLLM(options: ChatGptOAuthJudgeOptions): ToolCapableLLMPort;
+/** Internal deterministic seam; intentionally omitted from the package subpath exports. */
+export declare function createChatGptOAuthJudgeLLMWithDependencies(options: ChatGptOAuthJudgeOptions, dependencies?: ChatGptOAuthJudgeDependencies): ToolCapableLLMPort;
+export {};