@murphai/murph 1.3.1 → 1.3.2

package/node_modules/@murphai/assistant-engine/dist/assistant-codex.js

@@ -10,15 +10,17 @@ import { readHostedCanonicalWritePort, withHostedCanonicalWritePort, } from '@mu
 import { renderAssistantResponseCardText, renderAssistantResponseCardTranscriptText, renderAssistantWorkoutResponseCardText, renderAssistantWorkoutResponseCardTranscriptText, } from '@murphai/operator-config/assistant-response-cards';
 import { registerStopWarmCodexAppServer, registerWaitForWarmCodexBackgroundWork, } from './codex-lifecycle.js';
 import { extractAssistantMessageFallback, extractCodexErrorInfo, extractCodexErrorMessage, extractCodexCompletedFinalAgentMessageTextFromNormalized, extractCodexProgressEventFromNormalized, isCodexCompletedFinalAgentMessageItemFromNormalized, isCodexCompletedUserMessageItemFromNormalized, extractCodexStatusEventFromStderrLine, extractCodexTraceUpdatesFromNormalized, extractCodexContextCompactionProgressTextFromNormalized, normalizeCodexEvent, normalizeStreamingText, } from './assistant-codex-events.js';
-import { buildCodexTurnInterruptParams, buildCodexThreadResumeParams, buildCodexThreadStartParams, buildCodexTurnSteerParams, buildCodexTurnStartParams, mapCodexAppServerApprovalPolicy, mapCodexAppServerSandboxMode, resolveSupportedCodexAppServerApprovalPolicy, } from './assistant-codex/app-server-requests.js';
+import { buildCodexTurnInterruptParams, buildCodexThreadMetadataResumeParams, buildCodexThreadResumeParams, buildCodexThreadStartParams, buildCodexTurnSteerParams, buildCodexTurnStartParams, mapCodexAppServerApprovalPolicy, mapCodexAppServerSandboxMode, resolveSupportedCodexAppServerApprovalPolicy, } from './assistant-codex/app-server-requests.js';
 import { createCodexActionDiagnosticsReducer, createCodexActionRuntimeIssueTracker, } from './assistant-codex/action-diagnostics.js';
-import { MURPH_ASSISTANT_STYLE_TOOL, MURPH_GROUP_ROOM_MODEL_TOOL, } from './assistant-codex/dynamic-tool-catalog.js';
+import { createCodexWorkoutDeliveryContextTracker, } from './assistant-codex/workout-delivery-context.js';
+import { MURPH_ASSISTANT_STYLE_TOOL, MURPH_GROUP_ROOM_MODEL_TOOL, MURPH_MEMBER_MEMORY_TOOL, } from './assistant-codex/dynamic-tool-catalog.js';
 import { createAskGrokTurnState, } from './assistant-codex/ask-grok-tool.js';
+import { createAnalyzeVideoTurnState, } from './assistant-codex/analyze-video-tool.js';
 import { attachCodexAppServerProcessExitCleanup, attachCodexAbortListener, consumeCompleteLines, denyUnsupportedCodexServerRequest, rejectCodexServerRequest, readCodexRpcResponseId, readCodexRpcServerRequestId, rejectPendingCodexRpcRequests, resolvePendingCodexRpcRequest, signalCodexAppServerChild, stopCodexAppServerChild, stripUndefinedRpcParams, tryParseJsonLine, waitForCodexSpawn, withCodexRpcTimeout, writeCodexRpcMessage, } from './assistant-codex/app-server-rpc.js';
 import { readCodexNonEmptyString, readCodexRecord, readCodexThreadTokenUsage, } from './assistant-codex/app-server-protocol.js';
 import { resolveCodexChildEnv, withHostedCodexModelCatalogConfigOverride, } from './assistant-codex/config.js';
 import { buildCodexProcessExitError, buildCodexStdinFailureFallback, buildCodexTurnFailedError, extractCodexThreadIdFromMessage, extractCodexThreadIdFromResult, extractCodexThreadPathFromResult, extractCodexTurnErrorMessage, extractCodexTurnIdFromMessage, extractCodexTurnIdFromResult, extractCodexTurnStatus, isFailedCodexTurnStatus, readNodeErrorCode, } from './assistant-codex/failures.js';
-import { extractCodexSubagentUsageDrafts, isAssistantCodexTokenUsageEventType, readCodexCollabReceiverThreadIds, } from './assistant/providers/helpers.js';
+import { buildCodexSubagentUsageDraft, extractCodexSubagentUsageDrafts, isAssistantCodexTokenUsageEventType, } from './assistant/providers/helpers.js';
 import { materializeCodexImages, normalizeCodexAppServerImageDetails, } from './assistant-codex/images.js';
 import { ASSISTANT_AUTHORED_RESPONSE_MEDIA_MAX_ITEMS, normalizeAssistantResponseMediaList, } from './assistant/response-media.js';
 import { completeAssistantProviderStartCriticalPath, readAssistantProviderStartMonotonicTickMs, stampAssistantProviderStartCriticalPath, } from './assistant/provider-start-critical-path.js';
@@ -53,9 +55,6 @@ const CODEX_TRANSPORT_DIAGNOSTICS_TRACE_TYPE = 'assistant.codex.transport_diagno
 const CODEX_GENERATED_AUDIO_PHASE_TIMING_TRACE_SCHEMA = 'murph.assistant-codex-generated-audio-phase-timing.v1';
 const CODEX_GENERATED_AUDIO_PHASE_TIMING_TRACE_TYPE = 'assistant.codex.generated_audio_phase_timing';
 const CODEX_APP_SERVER_STARTUP_STDERR_MAX_LENGTH = 16_384;
-// Bound on distinct subagent threads whose token usage is tracked per parent
-// turn. Far above any sane spawn fan-out; threads past the cap are ignored.
-const MAX_CODEX_SUBAGENT_USAGE_THREADS = 32;
 function prepareCodexRpcParams(method, params) {
     const stripped = stripUndefinedRpcParams(params);
     if (method === 'turn/start' &&
@@ -240,6 +239,7 @@ export async function executeCodexAppServerTurn(input) {
         publicInternetFetch: input.publicInternetFetch ?? null,
         tempRoot,
         voiceMemoRuntime: input.voiceMemoRuntime ?? null,
+        analyzeVideoRuntime: input.analyzeVideoRuntime ?? null,
         askGrokRuntime: input.askGrokRuntime ?? null,
     };
     let oneShotProcess = null;
@@ -424,8 +424,10 @@ class CodexAppServerProcess {
     // reply.
     detachedChildThreadIds = new Set();
     detachedCompletedChildThreadIds = new Set();
+    detachedChildMessageHandlers = new Map();
     detachedChildViolation = null;
     detachedRootThreadIds = new Set();
+    pendingDetachedUsageReports = new Set();
     stopCompleted = false;
     state = 'idle';
     stderrBuffer = '';
@@ -626,9 +628,18 @@ class CodexAppServerProcess {
         rejectPendingCodexRpcRequests(this.pendingRequests, error);
     }
     sendRequest(method, params) {
+        return this.beginRequest(method, params).promise;
+    }
+    sendRequestWithTimeout(input) {
+        const request = this.beginRequest(input.method, input.params);
+        return withCodexRpcTimeout(request.promise, input.timeoutMs, input.timeoutLabel, () => {
+            this.pendingRequests.delete(request.id);
+        });
+    }
+    beginRequest(method, params) {
         const id = this.nextRequestId;
         this.nextRequestId += 1;
-        return new Promise((resolve, reject) => {
+        const promise = new Promise((resolve, reject) => {
             this.pendingRequests.set(id, {
                 method,
                 reject,
@@ -644,6 +655,7 @@ class CodexAppServerProcess {
                 reject(failure);
             }
         });
+        return { id, promise };
     }
     sendNotification(method, params) {
         void this.writeRpcMessage({
@@ -668,6 +680,7 @@ class CodexAppServerProcess {
             this.assertBackgroundWorkProcessAvailable();
             await this.waitForDetachedChildren(signal);
             this.assertDetachedChildrenQuiescent();
+            await this.waitForDetachedUsageReports(signal);
             await this.assertNoBackgroundTerminals(signal);
             throwIfCodexBackgroundWorkWaitAborted(signal);
             this.assertBackgroundWorkProcessAvailable();
@@ -725,6 +738,18 @@ class CodexAppServerProcess {
             throw new VaultCliError('ASSISTANT_CODEX_BACKGROUND_WORK_FAILED', 'Detached Codex work was still active at the workspace boundary.', { retryable: true });
         }
     }
+    trackDetachedUsageReport(report) {
+        this.pendingDetachedUsageReports.add(report);
+        void report.finally(() => {
+            this.pendingDetachedUsageReports.delete(report);
+        });
+    }
+    async waitForDetachedUsageReports(signal) {
+        while (this.pendingDetachedUsageReports.size > 0) {
+            throwIfCodexBackgroundWorkWaitAborted(signal);
+            await Promise.all([...this.pendingDetachedUsageReports]);
+        }
+    }
     async assertNoBackgroundTerminals(signal) {
         const threadIds = new Set([
             ...this.detachedRootThreadIds,
@@ -744,6 +769,7 @@ class CodexAppServerProcess {
     clearDetachedChildBoundary() {
         this.detachedChildThreadIds.clear();
         this.detachedCompletedChildThreadIds.clear();
+        this.detachedChildMessageHandlers.clear();
         this.detachedChildViolation = null;
         this.detachedRootThreadIds.clear();
     }
@@ -763,6 +789,9 @@ class CodexAppServerProcess {
                 }
                 else {
                     this.detachedChildThreadIds.add(activity.agentThreadId);
+                    if (this.activeTurn?.onSubagentMessage) {
+                        this.detachedChildMessageHandlers.set(activity.agentThreadId, this.activeTurn.onSubagentMessage);
+                    }
                 }
             }
             else {
@@ -993,11 +1022,6 @@ class CodexAppServerProcess {
     noteBoundThreadModel(model) {
         this.boundThreadModel = normalizeNullableString(model);
     }
-    // Exposed so a freshly bound turn can route foreign-thread events before
-    // its own thread/start response has produced the new thread id.
-    get lastBoundThreadId() {
-        return this.boundThreadId;
-    }
     handleIdleServerMessage(message) {
         const responseId = readCodexRpcResponseId(message);
         if (responseId !== null) {
@@ -1021,11 +1045,41 @@ class CodexAppServerProcess {
             writeRpcMessage: (payload) => void this.writeRpcMessage(payload),
         });
     }
+    routeSubagentMessage(message) {
+        if (readCodexRpcResponseId(message) !== null) {
+            return false;
+        }
+        const threadId = extractCodexThreadIdFromMessage(message);
+        if (!threadId || this.detachedRootThreadIds.has(threadId)) {
+            return false;
+        }
+        let handler = this.detachedChildMessageHandlers.get(threadId);
+        const activeHandler = this.activeTurn?.onSubagentMessage;
+        if (!handler && activeHandler) {
+            // The app-server process is exclusively owned by Assistant Engine. A
+            // foreign thread notification on an active root is therefore enough to
+            // correlate that child with the current turn; parent item shape is not a
+            // billing authorization boundary.
+            handler = activeHandler;
+            this.detachedChildMessageHandlers.set(threadId, handler);
+        }
+        if (!handler) {
+            return false;
+        }
+        if (isCodexTurnStartedMethod(readCodexEventMethod(message))) {
+            this.detachedChildThreadIds.add(threadId);
+        }
+        handler(message);
+        return true;
+    }
     handleStdoutLine(line) {
         const parsed = tryParseJsonLine(line);
         if (parsed.ok) {
             this.observeDetachedChildLifecycle(parsed.value);
             this.observeThreadTokenUsage(parsed.value);
+            if (this.routeSubagentMessage(parsed.value)) {
+                return;
+            }
             if (this.activeTurn) {
                 this.activeTurn.onParsedMessage(parsed.value);
             }
@@ -1913,6 +1967,29 @@ function isCodexTurnStartedMethod(method) {
 function createCodexSubagentTurnUsageKey(input) {
     return `${input.threadId}\u0000${input.turnId}`;
 }
+function readCodexSubagentEffectiveMetadataResult(input) {
+    if (extractCodexThreadIdFromResult(input.result) !== input.threadId) {
+        return null;
+    }
+    const result = readCodexRecord(input.result);
+    if (!result) {
+        return null;
+    }
+    const model = readCodexNonEmptyString(result.model);
+    const modelProvider = readCodexNonEmptyString(result.modelProvider);
+    const serviceTier = result.serviceTier;
+    if (!model ||
+        !modelProvider ||
+        !Object.hasOwn(result, 'serviceTier') ||
+        (serviceTier !== null && serviceTier !== 'flex')) {
+        return null;
+    }
+    return {
+        model,
+        modelProvider,
+        serviceTier,
+    };
+}
 function isCodexTurnCompletedMethod(method) {
     return method === 'turn/completed';
 }
@@ -2071,6 +2148,9 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
     let firstAssistantResponseCompleted = false;
     let trailingSteerCandidate = null;
     let completedUserMessageOrdinal = -1;
+    const workoutDeliveryContext = createCodexWorkoutDeliveryContextTracker({
+        contextReferences: input.trustedContextReferences,
+    });
     let lastEventError = null;
     let lastEventErrorInfo = null;
     let responseMedia = [];
@@ -2087,8 +2167,9 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
     const reservedNoReplyDeliveryContextOrdinals = new Set();
     const additionalUsages = [];
     let nextDynamicToolUsageOrdinal = (input.providerRequestOrdinal ?? 0) + 1;
-    // Trusted turn-scoped murph.ask_grok provider-call ceiling: one counter per
-    // assistant turn, owned here and threaded into the dynamic-tool executor.
+    // Trusted turn-scoped provider-call ceilings: one counter per assistant turn,
+    // owned here and threaded into the dynamic-tool executor.
+    const analyzeVideoTurnState = createAnalyzeVideoTurnState();
     const askGrokTurnState = createAskGrokTurnState();
     const groupSharedReadTurnState = {
         currentSenderDecisionByMessageRef: new Map(),
@@ -2108,11 +2189,6 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
         }
         : null;
     const subagentTokenUsageByTurn = new Map();
-    const trackedSubagentUsageThreadIds = new Set();
-    // Thread ids named by this turn's collab tool calls (spawn/sendInput/...),
-    // collected live so evidenced subagent threads win buffer slots over
-    // stale/unattributed foreign threads when the cap is reached.
-    const collabReceiverThreadIds = new Set();
     let rolloutRelativePath = null;
     let providerActionCount = 0;
     const providerActionItemIds = new Set();
@@ -2120,12 +2196,14 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
     const runtimeIssueInputs = [];
     const actionRuntimeIssueTracker = createCodexActionRuntimeIssueTracker();
     let computerToolsLockedAfterUserPause = false;
+    let requiredFinalResponseFallback = null;
     const requiredVaultFileApprovalUrls = [];
     const requiredAutomationLocalAtClarifications = new Map();
     const actionDiagnostics = input.onTraceEvent
         ? createCodexActionDiagnosticsReducer()
         : null;
     let actionDiagnosticsTraceEmitted = false;
+    let requiredFinalResponseFallbackOutcome = null;
     const assistantStreams = new Map();
     const assistantStreamOrder = [];
     const externallyVisibleAssistantOutputDeliveryContexts = new Set();
@@ -2195,22 +2273,21 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             stderr,
         });
     };
-    // Subagent usage drafts are derived lazily from the buffered per-thread
-    // samples so both the success result and the failure context can include
-    // whatever child usage was observed before the turn settled.
-    const buildSubagentUsageDrafts = () => extractCodexSubagentUsageDrafts({
-        modelProvider: normalizeNullableString(input.modelProvider) ?? null,
-        ordinalStart: nextDynamicToolUsageOrdinal,
-        parentModel: normalizeNullableString(input.model) ?? null,
-        parentRawEvents: jsonEvents,
-        serviceTier: input.serviceTier ?? null,
-        subagentTokenUsageByTurn,
-    });
+    const buildSubagentUsageDrafts = () => input.onAdditionalUsage
+        ? []
+        : extractCodexSubagentUsageDrafts({
+            modelProvider: normalizeNullableString(input.modelProvider) ?? null,
+            ordinalStart: nextDynamicToolUsageOrdinal,
+            parentModel: normalizeNullableString(input.model) ?? null,
+            serviceTier: input.serviceTier ?? null,
+            subagentTokenUsageByTurn,
+        });
     const hasNoReplyFinalActionPatch = () => finalActionPatches.some((entry) => entry.patch.kind === 'none');
     const listNoReplyFinalActionPatchOrdinals = () => [...new Set(finalActionPatches
             .filter((entry) => entry.patch.kind === 'none')
             .map((entry) => entry.deliveryContextOrdinal))].sort((left, right) => left - right);
     const hasRequiredUserVisibleOutput = () => computerToolsLockedAfterUserPause ||
+        requiredFinalResponseFallback !== null ||
         requiredAutomationLocalAtClarifications.size > 0 ||
         requiredVaultFileApprovalUrls.length > 0;
     const settleNoReplyFinalActions = async () => {
@@ -2516,6 +2593,11 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
                 ? renderAssistantWorkoutResponseCardTranscriptText(trailingSteerCandidate.cardTextFallback)
                 : response;
         precedingAgentMessageSegments.push({
+            ...(trailingSteerCandidate.contextReferences === undefined
+                ? {}
+                : {
+                    contextReferences: trailingSteerCandidate.contextReferences,
+                }),
             deliveryContextOrdinal: trailingSteerCandidate.deliveryContextOrdinal,
             media: [...trailingSteerCandidate.media],
             response,
@@ -3158,6 +3240,9 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
                 groupRoomModelAvailable: input.dynamicTools.some((tool) => tool.namespace === MURPH_GROUP_ROOM_MODEL_TOOL.namespace &&
                     tool.name === MURPH_GROUP_ROOM_MODEL_TOOL.name),
                 groupRoomModelMaintenanceAuthorized: input.groupRoomModelMaintenanceAuthorized === true,
+                memberMemoryAvailable: input.dynamicTools.some((tool) => tool.namespace === MURPH_MEMBER_MEMORY_TOOL.namespace &&
+                    tool.name === MURPH_MEMBER_MEMORY_TOOL.name),
+                memberMemoryMaintenanceAuthorized: input.memberMemoryMaintenanceAuthorized === true,
                 abortSignal: input.abortSignal
                     ? AbortSignal.any([input.abortSignal, dynamicToolAbortController.signal])
                     : dynamicToolAbortController.signal,
@@ -3204,6 +3289,10 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
                     dynamicToolRequest.kind === 'generate-song'
                     ? input.voiceMemoRuntime ?? null
                     : null,
+                analyzeVideoRuntime: dynamicToolRequest.kind === 'analyze-video'
+                    ? input.analyzeVideoRuntime ?? null
+                    : null,
+                analyzeVideoTurnState,
                 askGrokRuntime: dynamicToolRequest.kind === 'ask-grok'
                     ? input.askGrokRuntime ?? null
                     : null,
@@ -3215,6 +3304,19 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             if (dynamicToolRequest.kind === 'send-progress-update') {
                 releaseDynamicProgressPending?.();
             }
+            if (dynamicToolRequest.kind === 'analyze-video') {
+                const analyzeVideoFallback = normalizeNullableString(result.requiredFinalResponseFallback);
+                if (analyzeVideoFallback !== null) {
+                    if (result.rpcResult.success) {
+                        requiredFinalResponseFallback = analyzeVideoFallback;
+                        requiredFinalResponseFallbackOutcome = 'analyze-video-success';
+                    }
+                    else if (requiredFinalResponseFallbackOutcome !== 'analyze-video-success') {
+                        requiredFinalResponseFallback = analyzeVideoFallback;
+                        requiredFinalResponseFallbackOutcome = 'analyze-video-failure';
+                    }
+                }
+            }
             for (const runtimeIssueInput of result.runtimeIssueInputs ?? []) {
                 pushRuntimeIssueInput(runtimeIssueInput);
             }
@@ -3430,9 +3532,6 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
                 codexTimingTurnCompletedNotificationElapsedMs = Math.max(0, observedAtMs - providerRequestStartedAtMs);
             }
         }
-        for (const receiverThreadId of readCodexCollabReceiverThreadIds(message)) {
-            collabReceiverThreadIds.add(receiverThreadId);
-        }
         lastEventError = extractCodexErrorMessage(message) ?? lastEventError;
         lastEventErrorInfo = extractCodexErrorInfo(message) ?? lastEventErrorInfo;
         const normalizedEvent = normalizeCodexEvent(message);
@@ -3480,6 +3579,10 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             providerActionCount += 1;
         }
         const deliveryContextOrdinal = currentDeliveryContextOrdinal();
+        workoutDeliveryContext.observe({
+            deliveryContextOrdinal,
+            event: normalizedEvent,
+        });
         const suppressDeliveryContext = shouldSuppressDeliveryContext(deliveryContextOrdinal);
         const isCommentaryAssistantMessage = normalizedEvent.kind === 'assistant_message' &&
             normalizedEvent.messagePhase === 'commentary';
@@ -3520,6 +3623,7 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             (completedFinalAgentMessageText !== null ||
                 responseMedia.length > 0);
         if (completedFinalAgentResponse && !suppressDeliveryContext) {
+            workoutDeliveryContext.recordCompletedResponse(deliveryContextOrdinal);
             promoteTrailingSteerCandidate();
             completedFinalAgentMessage = completedFinalAgentMessageText ?? '';
             if (!firstAssistantResponseCompleted) {
@@ -3531,7 +3635,9 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             if (completedFinalAgentMessage !== null) {
                 const completedResponseDeliveryContextOrdinal = Math.max(0, completedUserMessageOrdinal);
                 const completedResponseTargetInputId = resolveReplyTargetPatch(completedResponseDeliveryContextOrdinal)?.targetInputId ?? null;
+                const contextReferences = workoutDeliveryContext.readReferences(completedResponseDeliveryContextOrdinal);
                 trailingSteerCandidate = {
+                    ...(contextReferences === undefined ? {} : { contextReferences }),
                     deliveryContextOrdinal: completedResponseDeliveryContextOrdinal,
                     response: completedFinalAgentMessage,
                     media: [...responseMedia],
@@ -3618,33 +3724,17 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             if (subagentTokenUsageByTurn.has(usageKey)) {
                 return;
             }
-            if (!trackedSubagentUsageThreadIds.has(threadId)
-                && trackedSubagentUsageThreadIds.size >= MAX_CODEX_SUBAGENT_USAGE_THREADS) {
-                const evictableThreadId = collabReceiverThreadIds.has(threadId)
-                    ? [...trackedSubagentUsageThreadIds].find((trackedThreadId) => !collabReceiverThreadIds.has(trackedThreadId))
-                    : undefined;
-                if (evictableThreadId === undefined) {
-                    return;
-                }
-                trackedSubagentUsageThreadIds.delete(evictableThreadId);
-                for (const [trackedUsageKey, sample] of subagentTokenUsageByTurn) {
-                    if (sample.threadId === evictableThreadId) {
-                        subagentTokenUsageByTurn.delete(trackedUsageKey);
-                    }
-                }
-            }
-            trackedSubagentUsageThreadIds.add(threadId);
             subagentTokenUsageByTurn.set(usageKey, {
                 firstEvent: null,
                 lastEvent: null,
                 occurredAt: new Date().toISOString(),
+                providerRequestOutcome: 'succeeded',
                 threadId,
                 turnId: messageTurnId,
             });
             return;
         }
-        if (!isAssistantCodexTokenUsageEventType(eventMethod)
-            || !messageTurnId) {
+        if (!messageTurnId) {
             return;
         }
         const usageKey = createCodexSubagentTurnUsageKey({
@@ -3652,10 +3742,32 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             turnId: messageTurnId,
         });
         const sample = subagentTokenUsageByTurn.get(usageKey);
+        if (isCodexTurnCompletedMethod(eventMethod)) {
+            if (!sample) {
+                return;
+            }
+            const status = extractCodexTurnStatus(message);
+            sample.providerRequestOutcome = status === 'interrupted'
+                ? 'aborted'
+                : isFailedCodexTurnStatus(status)
+                    ? 'partial'
+                    : 'succeeded';
+            if (!input.onAdditionalUsage) {
+                return;
+            }
+            // Removing the terminal sample is the exactly-once fence.
+            subagentTokenUsageByTurn.delete(usageKey);
+            if (sample.firstEvent === null || sample.lastEvent === null) {
+                return;
+            }
+            reportSubagentUsage(sample);
+            return;
+        }
+        if (!isAssistantCodexTokenUsageEventType(eventMethod)) {
+            return;
+        }
         if (!sample) {
-            // A child token sample without an observed start has no safe accounting
-            // timestamp. Parent collab evidence authorizes the child but cannot
-            // establish when its provider operation began.
+            // A child token sample without an observed start has no accounting timestamp.
             return;
         }
         sample.firstEvent ??= message;
@@ -3727,19 +3839,6 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             }
             return;
         }
-        // Codex owns subagent/thread lifecycle. Murph only keeps foreign thread
-        // traffic away from the active parent turn: token usage is buffered for
-        // billing, server requests are denied, and other child events are dropped.
-        // Before a fresh thread/start response produces this turn's thread id, the
-        // previous bound thread id is enough to distinguish late child traffic.
-        const messageThreadId = extractCodexThreadIdFromMessage(message);
-        const knownParentThreadId = codexThreadId ?? requestedResumeThreadId ?? codexProcess.lastBoundThreadId;
-        if (messageThreadId !== null &&
-            knownParentThreadId !== null &&
-            messageThreadId !== knownParentThreadId) {
-            handleSubagentThreadMessage(messageThreadId, message);
-            return;
-        }
         const messageTurnId = extractCodexTurnIdFromMessage(message);
         const method = readCodexEventMethod(message);
         const requestId = readCodexRpcServerRequestId(message);
@@ -3785,6 +3884,12 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             method !== 'model/rerouted') {
             return;
         }
+        if (method === 'rawResponseItem/completed' ||
+            method === 'rawResponse/completed') {
+            // Raw response notifications can contain provider payload content and
+            // do not belong in the parent turn's persisted event surface.
+            return;
+        }
         handleAcceptedEvent(message, method);
     }
     const emitActionDiagnosticsTrace = () => {
@@ -3814,6 +3919,31 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
         }
     };
     const sendRequest = (method, params) => codexProcess.sendRequest(method, params);
+    const readSubagentEffectiveMetadata = (threadId) => codexProcess.sendRequestWithTimeout({
+        method: 'thread/resume',
+        params: buildCodexThreadMetadataResumeParams(threadId),
+        timeoutLabel: 'thread/resume',
+        timeoutMs: CODEX_BACKGROUND_WORK_RPC_TIMEOUT_MS,
+    }).then((result) => readCodexSubagentEffectiveMetadataResult({ result, threadId })).catch(() => null);
+    const reportSubagentUsage = (sample) => {
+        const ordinal = nextDynamicToolUsageOrdinal++;
+        const report = readSubagentEffectiveMetadata(sample.threadId)
+            .then(async (metadata) => {
+            if (!metadata) {
+                return;
+            }
+            const draft = buildCodexSubagentUsageDraft({
+                metadata,
+                ordinal,
+                sample,
+            });
+            if (draft) {
+                await input.onAdditionalUsage?.(draft);
+            }
+        })
+            .catch(() => undefined);
+        codexProcess.trackDetachedUsageReport(report);
+    };
     const requireLiveTurnIds = () => {
         if (!liveTurnOpen || !codexThreadId || !turnId) {
             throw buildLiveTurnInactiveError();
@@ -3914,6 +4044,12 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             }));
         },
         onParsedMessage: handleParsedMessage,
+        onSubagentMessage(message) {
+            const threadId = extractCodexThreadIdFromMessage(message);
+            if (threadId) {
+                handleSubagentThreadMessage(threadId, message);
+            }
+        },
         onStderrLine(line) {
             const progressEvent = extractCodexStatusEventFromStderrLine(line);
             if (progressEvent) {
@@ -3963,12 +4099,6 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
                 threadResult,
             });
         }
-        else if (normalizeNullableString(input.permissions)) {
-            assertCodexThreadStartPermissionAttestation({
-                input,
-                threadResult,
-            });
-        }
         codexThreadId = extractCodexThreadIdFromResult(threadResult) ?? codexThreadId;
         codexProcess.noteBoundThreadId(codexThreadId);
         rolloutRelativePath = resolveCodexRolloutRelativePath({
@@ -4147,19 +4277,25 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
         : finalResponseCardTextFallback
             ? renderAssistantWorkoutResponseCardText(finalResponseCardTextFallback)
             : modelFinalMessage;
+    const requiredSemanticFinalMessage = normalizeNullableString(semanticFinalMessage) ??
+        requiredFinalResponseFallback ??
+        semanticFinalMessage;
     const requiredAutomationLocalAtClarificationsInOrder = [...requiredAutomationLocalAtClarifications.values()];
     const deliveredFinalResponseCard = requiredAutomationLocalAtClarificationsInOrder.length === 0
         ? finalResponseCard
         : null;
-    const finalMessage = appendRequiredVaultFileApprovalUrls(appendRequiredAutomationLocalAtClarification(semanticFinalMessage, requiredAutomationLocalAtClarificationsInOrder), requiredVaultFileApprovalUrls);
-    const transcriptMessage = appendRequiredAutomationLocalAtClarification(finalResponseCard
+    const finalMessage = appendRequiredVaultFileApprovalUrls(appendRequiredAutomationLocalAtClarification(requiredSemanticFinalMessage, requiredAutomationLocalAtClarificationsInOrder), requiredVaultFileApprovalUrls);
+    const semanticTranscriptMessage = finalResponseCard
         ? requiredAutomationLocalAtClarificationsInOrder.length === 0
             ? renderAssistantResponseCardTranscriptText(finalResponseCard)
             : renderAssistantResponseCardText(finalResponseCard)
         : finalResponseCardTextFallback
             ? renderAssistantWorkoutResponseCardTranscriptText(finalResponseCardTextFallback)
             : normalizeNullableString(modelFinalMessage) ??
-                (finalResponseMedia.length > 0 ? '' : null), requiredAutomationLocalAtClarificationsInOrder);
+                (finalResponseMedia.length > 0 ? '' : null);
+    const transcriptMessage = appendRequiredAutomationLocalAtClarification(normalizeNullableString(semanticTranscriptMessage) ??
+        requiredFinalResponseFallback ??
+        semanticTranscriptMessage, requiredAutomationLocalAtClarificationsInOrder);
     if (noReplySelected &&
         normalizeNullableString(extractedFinalMessage) !== null) {
         emitCodexSuppressedFinalMessageTrace({
@@ -4175,6 +4311,7 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
         (!noReplySelected && (finalResponseMedia.length > 0 ||
             deliveredFinalResponseCard !== null ||
             finalResponseCardTextFallback !== null));
+    const finalResponseContextReferences = workoutDeliveryContext.readReferences(finalDeliveryContextOrdinal);
     return {
         acceptedNoReplyDeliveryContextOrdinals: acceptedNoReplyDeliveryContextOrdinals,
         finalAction,
@@ -4188,6 +4325,9 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             targetInputId: entry.patch.targetInputId,
         })),
         precedingAgentMessageSegments: filteredPrecedingAgentMessageSegments.map((segment) => ({
+            ...(segment.contextReferences === undefined
+                ? {}
+                : { contextReferences: segment.contextReferences }),
             deliveryContextOrdinal: segment.deliveryContextOrdinal,
             response: segment.response,
             ...(segment.transcriptResponse === undefined
@@ -4199,6 +4339,9 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
                 : {}),
         })),
         responseDeliveryContextOrdinal: finalDeliveryContextOrdinal,
+        ...(finalResponseContextReferences === undefined
+            ? {}
+            : { responseContextReferences: finalResponseContextReferences }),
         targetInputId: resolveReplyTargetPatch(finalDeliveryContextOrdinal)?.targetInputId ?? null,
         additionalUsages: [...additionalUsages, ...buildSubagentUsageDrafts()],
         responseMedia: finalHasDeliverableOutput ? [...finalResponseMedia] : [],
@@ -4231,46 +4374,6 @@ function mergeAutomationRelativeDateReferenceWindows(preceding, current) {
         latestAt: new Date(latestAtMs).toISOString(),
     };
 }
-function assertCodexThreadStartPermissionAttestation(input) {
-    const result = asCodexRecord(input.threadResult);
-    const activePermissionProfile = asCodexRecord(result?.activePermissionProfile);
-    const actualCwd = normalizeNullableString(asCodexString(result?.cwd));
-    const actualRoots = asCodexStringArray(result?.runtimeWorkspaceRoots);
-    const instructionSources = Array.isArray(result?.instructionSources)
-        ? result.instructionSources
-        : null;
-    const expectedRoots = input.input.runtimeWorkspaceRoots ?? [];
-    const mismatchedFields = [];
-    const permissionProfileMismatch = normalizeNullableString(asCodexString(activePermissionProfile?.id)) !==
-        normalizeNullableString(input.input.permissions) ||
-        normalizeNullableString(asCodexString(activePermissionProfile?.extends)) !== null;
-    if (permissionProfileMismatch) {
-        mismatchedFields.push('activePermissionProfile');
-    }
-    if (!actualRoots ||
-        actualRoots.length !== expectedRoots.length ||
-        actualRoots.some((root, index) => path.resolve(root) !== path.resolve(expectedRoots[index] ?? ''))) {
-        mismatchedFields.push('runtimeWorkspaceRoots');
-    }
-    if (!actualCwd || path.resolve(actualCwd) !== input.input.workingDirectory) {
-        mismatchedFields.push('cwd');
-    }
-    if (input.input.processLifetime === 'one-shot' &&
-        (instructionSources === null || instructionSources.length !== 0)) {
-        mismatchedFields.push('instructionSources');
-    }
-    if (asCodexString(result?.approvalPolicy) !==
-        mapCodexAppServerApprovalPolicy(input.input.approvalPolicy)) {
-        mismatchedFields.push('approvalPolicy');
-    }
-    if (mismatchedFields.length === 0) {
-        return;
-    }
-    throw new VaultCliError('ASSISTANT_CODEX_APP_SERVER_PERMISSION_ATTESTATION_FAILED', 'Codex app-server did not attest the requested named-permission execution context.', {
-        mismatchedFields,
-        retryable: false,
-    });
-}
 function emitCodexSuppressedFinalMessageTrace(input) {
     if (!input.onTraceEvent) {
         return;
@@ -4338,20 +4441,7 @@ function notifyCodexAppServerProviderRequestStartedBestEffort(input) {
     }
 }
 function isInvalidDynamicToolRequest(request) {
-    return (request.kind === 'invalid-generate-image-arguments' ||
-        request.kind === 'invalid-automation-arguments' ||
-        request.kind === 'invalid-assistant-style-arguments' ||
-        request.kind === 'invalid-computer-arguments' ||
-        request.kind === 'invalid-device-arguments' ||
-        request.kind === 'invalid-generate-voice-memo-arguments' ||
-        request.kind === 'invalid-pending-vault-files-arguments' ||
-        request.kind === 'invalid-finish-without-reply-arguments' ||
-        request.kind === 'invalid-progress-arguments' ||
-        request.kind === 'invalid-reaction-arguments' ||
-        request.kind === 'invalid-reply-target-arguments' ||
-        request.kind === 'invalid-product-feedback-arguments' ||
-        request.kind === 'invalid-response-card-arguments' ||
-        request.kind === 'invalid-response-media-arguments');
+    return 'validationDigest' in request;
 }
 function isSerializedDynamicToolRequest(request) {
     return request.kind === 'automation' ||