@wix/pathgrade 1.0.17 → 1.0.18

package/dist/agents/claude/sdk-message-projector.js

@@ -22,6 +22,9 @@ const SDK_ERROR_SUBTYPES = [
     'error_max_structured_output_retries',
 ];
 import { TOOL_NAME_MAP, buildSummary, enrichSkillEvents } from '../../tool-events.js';
+import { sanitizePersistenceValue } from '../../tool-event-results.js';
+import { attachTurnResultSensitiveValues } from '../../sdk/turn-result-secrets.js';
+import { attachToolEventSensitiveValues } from '../../sdk/tool-event-secrets.js';
 import { attachOriginalMcpInput } from '../../sdk/mcp-event-input.js';
 import { parseClaudeSdkMcpToolName } from './mcp-tool-name.js';
 import { applyObservedToolResult, extractObservedToolResults, } from './tool-results.js';
@@ -132,13 +135,15 @@ export function projectSdkMessages(input) {
     const trimmedAssistant = assistantText.trim();
     const trimmedResult = resultText.trim();
     const visible = isError ? '' : (trimmedAssistant || trimmedResult);
-    const rawOutput = resultText || assistantText;
+    const rawOutput = sanitizePersistenceValue(resultText || assistantText, input.sensitiveValues);
     const enriched = enrichSkillEvents([
         ...toolEvents,
         ...(input.deniedMcpEvents?.all() ?? []),
     ]);
-    const finalToolEvents = prependSlashCommandSkillEvent(enriched, input.firstMessage, initSkills);
-    const traceOutput = input.messages.map((m) => JSON.stringify(m)).join('\n');
+    const finalToolEvents = prependSlashCommandSkillEvent(enriched, input.firstMessage, initSkills).map((event) => attachToolEventSensitiveValues(event, input.sensitiveValues ?? []));
+    const traceOutput = sanitizePersistenceValue(input.messages, input.sensitiveValues)
+        .map((message) => JSON.stringify(message))
+        .join('\n');
     const result = {
         rawOutput,
         assistantMessage: visible,
@@ -155,7 +160,10 @@ export function projectSdkMessages(input) {
         ...(costUsd !== undefined ? { costUsd } : {}),
         ...(errorSubtype !== undefined ? { errorSubtype } : {}),
     };
-    return { result, sessionId };
+    return {
+        result: attachTurnResultSensitiveValues(result, input.sensitiveValues ?? []),
+        sessionId,
+    };
 }
 /**
  * If the first user message of the turn is `/<name>` and `<name>` is one of

package/dist/agents/claude/tool-results.d.ts

@@ -1,6 +1,6 @@
 import type { SDKMessage } from '@anthropic-ai/claude-agent-sdk';
 import type { ToolEvent } from '../../tool-events.js';
-export declare const TOOL_RESULT_MAX_CHARS: number;
+export { collectSensitiveEnvValues, TOOL_RESULT_MAX_CHARS } from '../../tool-event-results.js';
 export interface ClaudeSdkMessageTiming {
     receivedAt: string;
     receivedMonotonicMs: number;
@@ -16,4 +16,3 @@ export interface ObservedToolResult {
 export declare function hasToolLifecycleBoundary(message: SDKMessage): boolean;
 export declare function extractObservedToolResults(message: SDKMessage, timing?: ClaudeSdkMessageTiming): ObservedToolResult[];
 export declare function applyObservedToolResult(event: ToolEvent, observed: ObservedToolResult, startedMonotonicMs?: number, sensitiveValues?: readonly string[]): void;
-export declare function collectSensitiveEnvValues(env: Readonly<Record<string, string>>): string[];

package/dist/agents/claude/tool-results.js

@@ -1,5 +1,5 @@
-export const TOOL_RESULT_MAX_CHARS = 64 * 1024;
-const SECRET_ENV_KEY_PATTERN = /(^|[_-])(api[_-]?key|token|secret|password|authorization|auth|bearer)([_-]|$)/i;
+import { sanitizeToolEventResult, } from '../../tool-event-results.js';
+export { collectSensitiveEnvValues, TOOL_RESULT_MAX_CHARS } from '../../tool-event-results.js';
 export function hasToolLifecycleBoundary(message) {
     if (message.type !== 'assistant' && message.type !== 'user')
         return false;
@@ -52,50 +52,19 @@ export function applyObservedToolResult(event, observed, startedMonotonicMs, sen
         event.arguments.status = event.status;
     }
 }
-export function collectSensitiveEnvValues(env) {
-    return [...new Set(Object.entries(env)
-            .filter(([key, value]) => SECRET_ENV_KEY_PATTERN.test(key) && value.length > 0)
-            .map(([, value]) => value))]
-        .sort((a, b) => b.length - a.length);
-}
 function buildBoundedToolResult(observed, sensitiveValues) {
     const raw = observed.structuredResult;
-    const result = {};
-    let truncated = false;
-    const addBounded = (key, value) => {
-        if (typeof value !== 'string')
-            return;
-        const bounded = boundText(redactSensitiveValues(value, sensitiveValues));
-        result[key] = bounded.value;
-        truncated ||= bounded.truncated;
+    const result = {
+        ...(typeof raw?.stdout === 'string' ? { stdout: raw.stdout } : {}),
+        ...(typeof raw?.stderr === 'string' ? { stderr: raw.stderr } : {}),
+        ...(typeof observed.content === 'string' && observed.content !== raw?.stdout
+            ? { content: observed.content }
+            : {}),
     };
-    addBounded('stdout', raw?.stdout);
-    addBounded('stderr', raw?.stderr);
-    if (observed.content !== raw?.stdout)
-        addBounded('content', observed.content);
     const exitCode = raw?.exitCode ?? raw?.exit_code;
     if (typeof exitCode === 'number' && Number.isFinite(exitCode))
         result.exitCode = exitCode;
-    if (truncated)
-        result.truncated = true;
-    return result;
-}
-function redactSensitiveValues(value, sensitiveValues) {
-    let redacted = value;
-    for (const secret of sensitiveValues) {
-        if (secret.length > 0)
-            redacted = redacted.split(secret).join('<redacted>');
-    }
-    return redacted;
-}
-function boundText(value) {
-    if (value.length <= TOOL_RESULT_MAX_CHARS)
-        return { value, truncated: false };
-    const marker = '\n[truncated by PathGrade]';
-    return {
-        value: `${value.slice(0, TOOL_RESULT_MAX_CHARS - marker.length)}${marker}`,
-        truncated: true,
-    };
+    return sanitizeToolEventResult(result, sensitiveValues);
 }
 function extractTextContent(content) {
     if (typeof content === 'string')

package/dist/agents/claude.js

@@ -28,6 +28,8 @@ import { createSandboxedClaudeSpawn } from '../providers/sandboxed-claude-spawn.
 import { assertClaudeLiveMcpSafetyPreflight, assertStdioMcpServersStartForClaudeSdk, mountMcpForClaudeSdk, } from '../providers/mcp-runtime-mounting.js';
 import { buildClaudeSdkOptions, resolveClaudeCodeExecutable, } from './claude/sdk-options.js';
 import { projectSdkMessages } from './claude/sdk-message-projector.js';
+import { attachToolEventSensitiveValues } from '../sdk/tool-event-secrets.js';
+import { cloneTurnResultWithSensitiveValues } from '../sdk/turn-result-secrets.js';
 import { collectSensitiveEnvValues, hasToolLifecycleBoundary, } from './claude/tool-results.js';
 import { createAskUserAnswerStore } from './claude/ask-user-answer-store.js';
 import { createClaudeToolPermissionBridge } from './claude/tool-permission-bridge.js';
@@ -195,7 +197,8 @@ export class ClaudeAgent extends BaseAgent {
                 deniedMcpEvents,
                 sensitiveValues,
             });
-            projected.result.toolEvents = [...scriptedEvents, ...projected.result.toolEvents];
+            projected.result.toolEvents = [...scriptedEvents, ...projected.result.toolEvents]
+                .map((event) => attachToolEventSensitiveValues(event, sensitiveValues));
             // Capture the SDK-reported session id BEFORE checking for a bus
             // rejection so the next turn's `Options.resume` points at this
             // turn's session even when the turn ended in an ask-bus error.
@@ -214,12 +217,11 @@ export class ClaudeAgent extends BaseAgent {
                 const errorMessage = bridgeError instanceof Error
                     ? bridgeError.message
                     : String(bridgeError);
-                return {
-                    ...projected.result,
+                return cloneTurnResultWithSensitiveValues(projected.result, {
                     exitCode: 1,
                     errorSubtype: 'bus_rejection',
                     rawOutput: errorMessage,
-                };
+                });
             }
             return projected.result;
         };

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

@@ -1,5 +1,6 @@
 import { AgentCommandRunner, AgentSession, AgentSessionOptions, BaseAgent, EnvironmentHandle } from '../../types.js';
 import { type AppServerSessionHandle } from './transport.js';
+import { type LifecycleClock } from './item-lifecycle.js';
 type SandboxMode = 'workspace-write' | 'danger-full-access';
 export interface PermissionGrantLogEntry {
     type: 'permissions_granted';
@@ -25,6 +26,8 @@ export interface CodexAppServerAgentDeps {
     sandboxMode?: SandboxMode;
     /** Observer for per-grant audit entries (§7 of design decisions). */
     onPermissionGrant?: (entry: PermissionGrantLogEntry) => void;
+    /** Injectable clocks keep wall timestamps and monotonic durations independently testable. */
+    clock?: LifecycleClock;
 }
 export declare class CodexAppServerAgent extends BaseAgent {
     private deps;

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

@@ -1,133 +1,21 @@
 import { BaseAgent, getRuntimeEnv, getWorkspacePath, } from '../../types.js';
 import { mountMcpForCodexAppServer } from '../../providers/mcp-runtime-mounting.js';
 import { assertMcpSecretReferencesReady } from '../../providers/mcp-config.js';
-import { buildSummary, enrichSkillEvents, extractSkillNameFromPath, inferCodexExecAction, } from '../../tool-events.js';
+import { enrichSkillEvents, } from '../../tool-events.js';
+import { collectSensitiveEnvValues, sanitizePersistenceValue, } from '../../tool-event-results.js';
 import { requireAskBusForLiveBatches } from '../../sdk/ask-bus/bus.js';
+import { attachTurnResultSensitiveValues } from '../../sdk/turn-result-secrets.js';
+import { attachToolEventSensitiveValues } from '../../sdk/tool-event-secrets.js';
 import { toAskUserToolEvent } from '../../sdk/ask-bus/projection.js';
 import { decideMcpToolCall } from '../../sdk/mcp-safety.js';
-import { attachOriginalMcpInput } from '../../sdk/mcp-event-input.js';
 import { spawnAppServerTransport, } from './transport.js';
 import { normalizeUpstreamQuestion, toWireAnswerMap, } from './wire-translators.js';
 import { extractTurnCompletionFailure } from './turn-completion.js';
 import { resolveCodexModel } from '../codex-model.js';
 import { CodexMcpApprovalCorrelator, extractMcpToolApprovalRequest, hasScriptedApprovalPolicy, isMcpToolCallApprovalRequest, recordPolicyDeniedMcpToolCall } from './mcp-approval-correlator.js';
+import { projectItemIntoTurn } from './item-projection.js';
+import { CodexItemLifecycle, } from './item-lifecycle.js';
 const TURN_COMPLETED_METHOD = 'turn/completed';
-function recordFromUnknown(value) {
-    if (value && typeof value === 'object' && !Array.isArray(value)) {
-        return value;
-    }
-    return {};
-}
-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) {
-    if (!value)
-        return undefined;
-    return value.match(/(?:^|[/\s"'])\.(?:agents|claude)\/skills\/([^/\s"']+)\/SKILL\.md(?:$|[\s"'])/)?.[1];
-}
-function extractSkillPathFromText(value) {
-    if (!value)
-        return undefined;
-    return value.match(/(?:^|[\s"'])(?<path>(?:\/|\.{1,2}\/)?[^\s"']*(?:\.agents|\.claude)\/skills\/[^/\s"']+\/SKILL\.md)(?:$|[\s"'])/)?.groups?.path;
-}
-function projectItemIntoTurn(item, turn) {
-    if (item.type === 'agentMessage') {
-        const msg = item;
-        if (msg.text) {
-            turn.assistantMessageParts.push(msg.text);
-        }
-        return;
-    }
-    if (item.type === 'commandExecution') {
-        const cmd = item;
-        const action = inferCodexExecAction(cmd.command);
-        const skillPath = extractSkillPathFromText(cmd.command);
-        const args = {
-            command: cmd.command,
-            ...(skillPath ? { path: skillPath } : {}),
-        };
-        turn.nonAskToolEvents.push({
-            action,
-            provider: 'codex',
-            providerToolName: 'commandExecution',
-            turnNumber: turn.turnNumber,
-            arguments: args,
-            summary: buildSummary(action, 'commandExecution', args),
-            confidence: 'high',
-            rawSnippet: JSON.stringify(cmd),
-        });
-        const recordedSkills = new Set();
-        for (const action of cmd.commandActions ?? []) {
-            const skillName = extractCommandActionSkillName(action) ?? extractSkillNameFromText(cmd.command);
-            if (!skillName || recordedSkills.has(skillName))
-                continue;
-            recordedSkills.add(skillName);
-            turn.nonAskToolEvents.push({
-                action: 'use_skill',
-                provider: 'codex',
-                providerToolName: `commandExecution.commandActions.${action.type ?? 'unknown'}`,
-                turnNumber: turn.turnNumber,
-                arguments: { path: action.path, name: action.name },
-                summary: `use_skill ${skillName}`,
-                confidence: 'high',
-                rawSnippet: JSON.stringify(action),
-                skillName,
-            });
-        }
-        return;
-    }
-    if (item.type === 'fileChange') {
-        const fc = item;
-        for (const change of fc.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') {
-        const call = item;
-        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}`;
-        turn.nonAskToolEvents.push(attachOriginalMcpInput({
-            action: 'mcp_tool_call',
-            provider: 'codex',
-            providerToolName,
-            toolUseId: call.id,
-            turnNumber: turn.turnNumber,
-            arguments: {
-                ...args,
-                server: call.server,
-                tool: call.tool,
-                status: call.status ?? 'unknown',
-            },
-            summary: `MCP tool ${providerToolName} ${call.status ?? 'unknown'}`,
-            confidence: 'high',
-            rawSnippet: JSON.stringify(call),
-            ...(call.result !== undefined ? { result: { content: JSON.stringify(call.result) } } : {}),
-        }, args));
-        return;
-    }
-}
 function projectMcpStartupStatusIntoTurn(params, turn) {
     const name = params.name ?? 'unknown';
     const status = params.status ?? 'unknown';
@@ -156,6 +44,18 @@ function failTurn(turn, message) {
     turn.failureMessage = message;
     turn.signalFailure?.(message);
 }
+function extractTurnCompletionIdentity(params) {
+    if (!params || typeof params !== 'object' || Array.isArray(params))
+        return {};
+    const record = params;
+    const turnId = typeof record.turn?.id === 'string'
+        ? record.turn.id
+        : typeof record.turnId === 'string' ? record.turnId : undefined;
+    return {
+        ...(typeof record.threadId === 'string' ? { threadId: record.threadId } : {}),
+        ...(turnId ? { turnId } : {}),
+    };
+}
 function isLiveMcpSafetyMode(options) {
     const runMode = options?.runMode ?? 'mock';
     return runMode === 'live-readonly' || runMode === 'live-sandbox' || runMode === 'live';
@@ -170,6 +70,7 @@ export class CodexAppServerAgent extends BaseAgent {
         const askBus = requireAskBusForLiveBatches(options, 'CodexAppServerAgent');
         const workspacePath = getWorkspacePath(runtime);
         const runtimeEnv = getRuntimeEnv(runtime);
+        const sensitiveValues = collectSensitiveEnvValues(runtimeEnv);
         const model = resolveCodexModel(options?.model);
         const sandboxMode = this.deps.sandboxMode ?? 'workspace-write';
         let handle = null;
@@ -207,7 +108,8 @@ export class CodexAppServerAgent extends BaseAgent {
             });
             transport.onNotification((n) => {
                 if (process.env.PATHGRADE_CODEX_DEBUG) {
-                    console.error(`[codex app-server] notification method=${n.method} params=${JSON.stringify(n.params).slice(0, 300)}`);
+                    const debugParams = sanitizePersistenceValue(n.params, sensitiveValues);
+                    console.error(`[codex app-server] notification method=${n.method} params=${JSON.stringify(debugParams).slice(0, 300)}`);
                 }
                 if (n.method === 'mcpServer/startupStatus/updated') {
                     const turn = activeTurn;
@@ -221,25 +123,14 @@ export class CodexAppServerAgent extends BaseAgent {
                     return;
                 const params = n.params;
                 if (n.method === 'item/started') {
-                    try {
-                        correlator?.started(n.params);
-                    }
-                    catch (error) {
-                        failTurn(turn, error instanceof Error ? error.message : String(error));
-                    }
+                    if (params)
+                        turn.itemLifecycle?.receiveStarted(params);
                     return;
                 }
                 if (n.method !== 'item/completed')
                     return;
-                if (!params?.item)
-                    return;
-                try {
-                    if (correlator?.completed(params) !== false)
-                        projectItemIntoTurn(params.item, turn);
-                }
-                catch (error) {
-                    failTurn(turn, error instanceof Error ? error.message : String(error));
-                }
+                if (params)
+                    turn.itemLifecycle?.receiveCompleted(params);
             });
             const initialized = await transport.sendRequest('initialize', {
                 clientInfo: { name: 'pathgrade', version: '0.5.0', title: null },
@@ -262,6 +153,7 @@ export class CodexAppServerAgent extends BaseAgent {
                 nonAskToolEvents: [],
                 assistantMessageParts: [],
                 turnFailed: false,
+                pendingTurnCompletions: [],
             };
             activeTurn = turn;
             correlator?.beginTurn();
@@ -286,6 +178,31 @@ export class CodexAppServerAgent extends BaseAgent {
                     }
                     threadId = resp.thread.id;
                 }
+                const authoritativeThreadId = threadId;
+                turn.authoritativeThreadId = authoritativeThreadId;
+                turn.itemLifecycle = new CodexItemLifecycle({
+                    threadId: authoritativeThreadId,
+                    clock: this.deps.clock,
+                    onFailure: (message) => failTurn(turn, message),
+                    onStarted: (params) => {
+                        try {
+                            correlator?.started(params);
+                        }
+                        catch (error) {
+                            failTurn(turn, error instanceof Error ? error.message : String(error));
+                        }
+                    },
+                    onCompleted: (item, timing, params) => {
+                        try {
+                            if (correlator?.completed(params) !== false) {
+                                projectItemIntoTurn(item, turn, sensitiveValues, timing);
+                            }
+                        }
+                        catch (error) {
+                            failTurn(turn, error instanceof Error ? error.message : String(error));
+                        }
+                    },
+                });
                 // Wait for TurnCompleted OR subprocess crash OR dispatcher failure.
                 const turnCompletion = new Promise((resolve, reject) => {
                     let settled = false;
@@ -293,15 +210,30 @@ export class CodexAppServerAgent extends BaseAgent {
                         if (settled)
                             return;
                         if (n.method === TURN_COMPLETED_METHOD) {
-                            settled = true;
-                            off();
-                            closeOff();
-                            const failure = extractTurnCompletionFailure(n.params);
-                            if (failure)
-                                Object.assign(turn, { turnFailed: true, failureMessage: failure });
-                            resolve();
+                            turn.acceptTurnCompletion?.(n.params);
                         }
                     });
+                    const acceptTurnCompletion = (params) => {
+                        if (settled)
+                            return;
+                        const identity = extractTurnCompletionIdentity(params);
+                        if (identity.threadId && identity.threadId !== turn.authoritativeThreadId)
+                            return;
+                        if (identity.turnId && !turn.authoritativeTurnId) {
+                            turn.pendingTurnCompletions.push(params);
+                            return;
+                        }
+                        if (identity.turnId && identity.turnId !== turn.authoritativeTurnId)
+                            return;
+                        settled = true;
+                        off();
+                        closeOff();
+                        const failure = extractTurnCompletionFailure(params);
+                        if (failure)
+                            Object.assign(turn, { turnFailed: true, failureMessage: failure });
+                        resolve();
+                    };
+                    turn.acceptTurnCompletion = acceptTurnCompletion;
                     const closeOff = t.onClose((info) => {
                         if (settled)
                             return;
@@ -339,9 +271,25 @@ export class CodexAppServerAgent extends BaseAgent {
                         }
                     }
                 });
-                const startTurnResp = t.sendRequest('turn/start', {
+                const authoritativeTurn = t.sendRequest('turn/start', {
                     threadId,
                     input: [{ type: 'text', text: message, text_elements: [] }],
+                })
+                    .then((started) => {
+                    const authoritativeTurnId = started.turn?.id ?? started.turnId;
+                    if (!authoritativeTurnId) {
+                        scriptedHost?.failProtocol('turn/start did not return an authoritative turn id');
+                        turn.signalFailure?.('turn/start did not return an authoritative turn id');
+                        return;
+                    }
+                    turn.itemLifecycle?.setAuthoritativeTurn(authoritativeTurnId);
+                    turn.authoritativeTurnId = authoritativeTurnId;
+                    if (correlator?.setAuthoritativeTurn(authoritativeThreadId, authoritativeTurnId) === false) {
+                        turn.signalFailure?.('MCP lifecycle did not match the authoritative turn');
+                    }
+                    for (const pending of turn.pendingTurnCompletions.splice(0)) {
+                        turn.acceptTurnCompletion?.(pending);
+                    }
                 })
                     .catch((err) => {
                     // A JSON-RPC error on turn/start means the server will
@@ -355,18 +303,6 @@ export class CodexAppServerAgent extends BaseAgent {
                             : 'turn/start failed';
                     turn.signalFailure?.(msg);
                 });
-                if (scriptedHost) {
-                    const started = await startTurnResp;
-                    if (!started?.turn?.id || !threadId) {
-                        scriptedHost.failProtocol('turn/start did not return an authoritative turn id');
-                        turn.signalFailure?.('turn/start did not return an authoritative turn id');
-                    }
-                    else {
-                        if (correlator?.setAuthoritativeTurn(threadId, started.turn.id) === false) {
-                            turn.signalFailure?.('MCP lifecycle did not match the authoritative turn');
-                        }
-                    }
-                }
                 try {
                     await turnCompletion;
                 }
@@ -379,16 +315,25 @@ export class CodexAppServerAgent extends BaseAgent {
                         message: info.message ?? 'app-server exited',
                         pid: info.pid,
                         signal: info.signal,
+                        sensitiveValues,
                     });
                 }
-                if (!scriptedHost)
-                    void startTurnResp;
                 if (turn.turnFailed) {
                     return assembleTurnResult({
                         askBus,
                         activeTurn: turn,
                         exitCode: 1,
                         message: turn.failureMessage ?? 'turn failed',
+                        sensitiveValues,
+                    });
+                }
+                // Ensure pre-response lifecycle notifications have been correlated
+                // and projected before exposing the successful turn result.
+                await authoritativeTurn;
+                if (turn.turnFailed) {
+                    return assembleTurnResult({
+                        askBus, activeTurn: turn, exitCode: 1,
+                        message: turn.failureMessage ?? 'turn failed', sensitiveValues,
                     });
                 }
                 return assembleTurnResult({
@@ -396,6 +341,7 @@ export class CodexAppServerAgent extends BaseAgent {
                     activeTurn: turn,
                     exitCode: 0,
                     message: turn.assistantMessageParts.join('\n\n'),
+                    sensitiveValues,
                 });
             }
             finally {
@@ -577,14 +523,15 @@ function buildThreadStartParams(opts) {
     };
 }
 function assembleTurnResult(args) {
-    const { askBus, activeTurn, exitCode, message, pid, signal } = args;
+    const { askBus, activeTurn, exitCode, message, pid, signal, sensitiveValues = [] } = args;
     const askBatchIds = new Set(activeTurn.askBatchIds);
     const askEvents = askBus
         .snapshot()
         .filter((s) => askBatchIds.has(s.batchId))
         .map((s) => toAskUserToolEvent(s));
-    const toolEvents = enrichSkillEvents([...askEvents, ...activeTurn.nonAskToolEvents]);
-    const rawOutput = exitCode === 0
+    const toolEvents = enrichSkillEvents([...askEvents, ...activeTurn.nonAskToolEvents])
+        .map((event) => attachToolEventSensitiveValues(event, sensitiveValues));
+    const rawOutput = sanitizePersistenceValue(exitCode === 0
         ? message
         : [
             message,
@@ -593,8 +540,8 @@ function assembleTurnResult(args) {
             `exitCode=${exitCode}`,
         ]
             .filter(Boolean)
-            .join(' ');
-    return {
+            .join(' '), sensitiveValues);
+    return attachTurnResultSensitiveValues({
         rawOutput,
         assistantMessage: exitCode === 0 ? message : '',
         visibleAssistantMessage: exitCode === 0 ? message : '',
@@ -611,5 +558,5 @@ function assembleTurnResult(args) {
                 },
             }
             : {}),
-    };
+    }, sensitiveValues);
 }

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

@@ -0,0 +1,30 @@
+import type { CodexItem, ItemTiming } from './item-projection.js';
+export interface ItemLifecycleParams {
+    item?: CodexItem;
+    threadId?: string;
+    turnId?: string;
+}
+export interface LifecycleClock {
+    wallNow(): number;
+    monotonicNow(): number;
+}
+export declare class CodexItemLifecycle {
+    private readonly options;
+    private turnId?;
+    private readonly pending;
+    private readonly started;
+    private readonly completed;
+    constructor(options: {
+        threadId: string;
+        clock?: LifecycleClock;
+        onStarted?: (params: ItemLifecycleParams) => void;
+        onCompleted: (item: CodexItem, timing: ItemTiming, params: ItemLifecycleParams) => void;
+        onFailure: (message: string) => void;
+    });
+    receiveStarted(params: ItemLifecycleParams): void;
+    receiveCompleted(params: ItemLifecycleParams): void;
+    setAuthoritativeTurn(turnId: string): boolean;
+    private receive;
+    private validateEnvelope;
+    private process;
+}