@wix/pathgrade 1.0.17 → 1.0.18

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

@@ -0,0 +1,95 @@
+import { performance } from 'node:perf_hooks';
+import { canonicalizeJson } from '../../core/canonical-json.js';
+export class CodexItemLifecycle {
+    options;
+    turnId;
+    pending = [];
+    started = new Map();
+    completed = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    receiveStarted(params) {
+        this.receive('started', params);
+    }
+    receiveCompleted(params) {
+        this.receive('completed', params);
+    }
+    setAuthoritativeTurn(turnId) {
+        if (!turnId) {
+            this.options.onFailure('turn/start did not return an authoritative turn id');
+            return false;
+        }
+        if (this.turnId && this.turnId !== turnId) {
+            this.options.onFailure('turn/start returned conflicting authoritative turn ids');
+            return false;
+        }
+        this.turnId = turnId;
+        for (const entry of this.pending.splice(0))
+            this.process(entry.phase, entry.receipt);
+        return true;
+    }
+    receive(phase, params) {
+        const clock = this.options.clock ?? DEFAULT_CLOCK;
+        const receipt = { params, wallMs: clock.wallNow(), monotonicMs: clock.monotonicNow() };
+        if (!this.validateEnvelope(params))
+            return;
+        if (!this.turnId) {
+            this.pending.push({ phase, receipt });
+            return;
+        }
+        this.process(phase, receipt);
+    }
+    validateEnvelope(params) {
+        if (!params.item || typeof params.item.id !== 'string' || !params.item.id
+            || typeof params.threadId !== 'string' || !params.threadId
+            || typeof params.turnId !== 'string' || !params.turnId) {
+            this.options.onFailure('Codex item lifecycle notification is missing threadId, turnId, or item.id');
+            return false;
+        }
+        // Notifications for an earlier thread are stale, not failures of this turn.
+        return params.threadId === this.options.threadId;
+    }
+    process(phase, receipt) {
+        const { params } = receipt;
+        if (params.turnId !== this.turnId || !params.item || typeof params.item.id !== 'string')
+            return;
+        const itemId = params.item.id;
+        const fingerprint = canonicalizeJson(params.item);
+        if (phase === 'started') {
+            const prior = this.started.get(itemId);
+            if (prior) {
+                if (prior.fingerprint !== fingerprint) {
+                    this.options.onFailure(`Conflicting item/started notification for item ${itemId}`);
+                }
+                return;
+            }
+            if (this.completed.has(itemId)) {
+                this.options.onFailure(`item/started arrived after item/completed for item ${itemId}`);
+                return;
+            }
+            this.started.set(itemId, { ...receipt, fingerprint });
+            this.options.onStarted?.(params);
+            return;
+        }
+        const priorTerminal = this.completed.get(itemId);
+        if (priorTerminal !== undefined) {
+            if (priorTerminal !== fingerprint) {
+                this.options.onFailure(`Conflicting item/completed notification for item ${itemId}`);
+            }
+            return;
+        }
+        this.completed.set(itemId, fingerprint);
+        const start = this.started.get(itemId);
+        this.started.delete(itemId);
+        this.options.onCompleted(params.item, {
+            ...(start ? { startedAtWallMs: start.wallMs } : {}),
+            completedAtWallMs: receipt.wallMs,
+            ...(start ? { observedDurationMs: Math.max(0, receipt.monotonicMs - start.monotonicMs) } : {}),
+        }, params);
+    }
+}
+const DEFAULT_CLOCK = {
+    wallNow: () => Date.now(),
+    monotonicNow: () => performance.now(),
+};

package/dist/agents/codex-app-server/item-projection.d.ts

@@ -0,0 +1,62 @@
+import { type ToolEvent } from '../../tool-events.js';
+export interface CodexTurnProjection {
+    turnNumber: number;
+    nonAskToolEvents: ToolEvent[];
+    assistantMessageParts: string[];
+}
+interface CodexCommandExecutionAction {
+    type?: string;
+    name?: string;
+    path?: string;
+    command?: string;
+}
+interface CodexCommandExecutionItem {
+    type: 'commandExecution';
+    id: string;
+    command: string;
+    status?: 'inProgress' | 'completed' | 'failed' | 'declined';
+    cwd?: string;
+    commandActions?: CodexCommandExecutionAction[];
+    aggregatedOutput?: string | null;
+    exitCode?: number | null;
+    durationMs?: number | null;
+}
+interface CodexMcpToolCallItem {
+    type: 'mcpToolCall';
+    id: string;
+    server: string;
+    tool: string;
+    status?: string;
+    arguments?: unknown;
+    result?: unknown;
+    error?: {
+        message?: string;
+    } | null;
+    durationMs?: number | null;
+}
+export type CodexItem = {
+    type: 'agentMessage';
+    id: string;
+    text: string;
+    phase?: string;
+} | CodexCommandExecutionItem | {
+    type: 'fileChange';
+    id: string;
+    changes: Array<{
+        path: string;
+        kind?: unknown;
+        diff?: string;
+    }>;
+} | CodexMcpToolCallItem | {
+    type: string;
+    id?: string;
+};
+export interface ItemTiming {
+    startedAtWallMs?: number;
+    completedAtWallMs?: number;
+    observedDurationMs?: number;
+}
+export declare function projectItemIntoTurn(item: CodexItem, turn: CodexTurnProjection, sensitiveValues: readonly string[], timing?: ItemTiming): void;
+/** Provider duration is authoritative; observed monotonic duration is the fallback. */
+export declare function projectToolTiming(timing: ItemTiming, providerDurationMs: number | undefined): Pick<ToolEvent, 'startedAt' | 'completedAt' | 'durationMs'>;
+export {};

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/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/providers/credentials.d.ts

@@ -39,6 +39,8 @@ export interface CredentialResult {
     linkFromHome?: string[];
     /** Filtered sensitive files to create inside the isolated HOME. */
     sensitiveHomeFiles?: SensitiveHomeFile[];
+    /** Runtime-only values that persistence sinks must redact. */
+    sensitiveValues?: string[];
 }
 /** Default ports using real process.env, Keychain, and filesystem. */
 export declare function defaultPorts(): CredentialPorts;

package/dist/providers/credentials.js

@@ -152,6 +152,7 @@ function filterOpenCodeOAuthRecord(raw) {
     const sanitized = { ...record, refresh: OPENCODE_DISABLED_REFRESH_TOKEN };
     return {
         env: {}, setupCommands: [], copyFromHome: [],
+        sensitiveValues: [record.access],
         sensitiveHomeFiles: [{
                 relativePath: path.join('.local', 'share', 'opencode', 'auth.json'),
                 content: JSON.stringify({ openai: sanitized }),

package/dist/providers/scripted-mcp-mock-host.js

@@ -7,6 +7,7 @@ import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprot
 import { compileScriptedMcpSchemaForProvider } from '../core/mcp-schema-profile.js';
 import { MCP_ANNOTATION_PROTOCOL_FLOOR } from '../core/generated-mcp-protocol.js';
 import { getOriginalMcpInput } from '../sdk/mcp-event-input.js';
+import { cloneToolEventWithRuntimeMetadata } from '../sdk/tool-event-secrets.js';
 import { createMcpArgumentDigest, createMcpReceiptKey, matchesMcpApprovalArguments, } from '../sdk/mcp-mock-approvals.js';
 let testObserver = null;
 /** Non-public acceptance seam. It observes only authenticated manifest-member calls. */
@@ -332,9 +333,11 @@ function eventInput(event) {
 }
 function withInvocation(event, identity, invocation) {
     const status = String(event.arguments?.status ?? 'unknown').toLowerCase();
-    return invocation === 'confirmed'
-        ? { ...event, mcp: { ...identity, invocation, outcome: status.includes('fail') || status.includes('error') ? 'tool_error' : 'completed' } }
-        : { ...event, mcp: { ...identity, invocation, outcome: 'unknown' } };
+    return cloneToolEventWithRuntimeMetadata(event, {
+        mcp: invocation === 'confirmed'
+            ? { ...identity, invocation, outcome: status.includes('fail') || status.includes('error') ? 'tool_error' : 'completed' }
+            : { ...identity, invocation, outcome: 'unknown' },
+    });
 }
 async function readJsonBody(req) {
     const chunks = [];

package/dist/providers/workspace.d.ts

@@ -6,6 +6,7 @@ export interface Workspace {
     readonly mcpConfigPath: string | undefined;
     readonly env: Record<string, string>;
     readonly setupCommands: string[];
+    readonly sensitiveValues?: readonly string[];
     exec(command: string, opts?: {
         signal?: AbortSignal;
     }): Promise<CommandResult>;

package/dist/providers/workspace.js

@@ -7,6 +7,7 @@ import { stageMcpConfig } from './mcp-config.js';
 import { sandboxExec } from './sandbox-exec.js';
 import { resolveCredentials } from './credentials.js';
 import { isPortableCopyEntry } from './copy-filter.js';
+import { collectSensitiveEnvValues } from '../tool-event-results.js';
 async function copyPathsFromHostHome(pathsToCopy, sandboxHomePath) {
     const realHome = os.homedir();
     for (const relPath of pathsToCopy) {
@@ -59,6 +60,10 @@ export async function prepareWorkspace(spec) {
             mcpConfigPath,
             env: sandboxEnv,
             setupCommands: creds.setupCommands,
+            sensitiveValues: [...new Set([
+                    ...collectSensitiveEnvValues(sandboxEnv),
+                    ...(creds.sensitiveValues ?? []),
+                ])],
             exec: (command, opts) => sandboxExec(command, { cwd: workspacePath, env: sandboxEnv }, opts),
             async dispose() {
                 if (disposed)

package/dist/sdk/agent-result-log.js

@@ -1,4 +1,6 @@
 import { getTurnResultLogMetadata, getVisibleAssistantMessage } from './visible-turn.js';
+import { sanitizePersistenceValue } from '../tool-event-results.js';
+import { getTurnResultSensitiveValues } from './turn-result-secrets.js';
 function getOutputMetrics(message) {
     return {
         output_lines: message.split('\n').length,
@@ -7,7 +9,7 @@ function getOutputMetrics(message) {
 }
 export function buildModelAgentResultLogEntry(params) {
     const assistantMessage = params.assistantMessage ?? getVisibleAssistantMessage(params.turnResult);
-    return {
+    return sanitizePersistenceValue({
         type: 'agent_result',
         timestamp: params.timestamp,
         ...(params.turnNumber === undefined ? {} : { turn_number: params.turnNumber }),
@@ -30,7 +32,7 @@ export function buildModelAgentResultLogEntry(params) {
             ? { error_subtype: params.turnResult.errorSubtype }
             : {}),
         ...getOutputMetrics(assistantMessage),
-    };
+    }, getTurnResultSensitiveValues(params.turnResult));
 }
 /**
  * Build one `ask_batch` LogEntry per AskBus batch emitted in the given turn.