@murphai/murph 1.3.0 → 1.3.1

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

@@ -3,23 +3,27 @@ import { createHash } from 'node:crypto';
 import { mkdtemp, rm, stat } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
+import { MURPH_MEMBER_WORKSPACE_PERMISSION_PROFILE, } from '@murphai/hosted-execution/assistant-permissions';
 import { normalizeNullableString } from '@murphai/operator-config/text/shared';
 import { VaultCliError } from '@murphai/operator-config/vault-cli-errors';
 import { readHostedCanonicalWritePort, withHostedCanonicalWritePort, } from '@murphai/core';
+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 { buildRuntimeIssueInputForFailedCodexAction, createCodexActionDiagnosticsReducer, } from './assistant-codex/action-diagnostics.js';
-import { executeMurphDynamicToolRequest, isComputerDynamicToolRequest, MURPH_ASSISTANT_STYLE_TOOL, MURPH_GROUP_ROOM_MODEL_TOOL, readMurphDynamicToolRequest, } from './assistant-codex/dynamic-tools.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 { createAskGrokTurnState, } from './assistant-codex/ask-grok-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 { materializeCodexImagePaths, } from './assistant-codex/images.js';
-import { normalizeAssistantResponseMediaList, } from './assistant/response-media.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';
 export { extractCodexTraceUpdates } from './assistant-codex-events.js';
-export { listMurphDynamicToolNames, resolveMurphDynamicTools, } from './assistant-codex/dynamic-tools.js';
+export { listMurphDynamicToolNames, resolveMurphDynamicTools, } from './assistant-codex/dynamic-tool-catalog.js';
 export { resolveCodexDisplayOptions } from './assistant-codex/config.js';
 const CODEX_RPC_CLIENT_NAME = 'murph';
 const CODEX_RPC_CLIENT_TITLE = 'Murph';
@@ -29,6 +33,12 @@ const CODEX_BACKGROUND_WORK_RPC_TIMEOUT_MS = 5_000;
 const CODEX_BACKGROUND_WORK_WAIT_TIMEOUT_MS = 120_000;
 const CODEX_BACKGROUND_WORK_POLL_INTERVAL_MS = 50;
 const CODEX_RPC_STEER_TIMEOUT_MS = 15_000;
+let murphDynamicToolRuntimePromise = null;
+function loadMurphDynamicToolRuntime() {
+    murphDynamicToolRuntimePromise ??=
+        import('./assistant-codex/dynamic-tools.js');
+    return murphDynamicToolRuntimePromise;
+}
 const CODEX_APP_SERVER_INTERRUPT_CLEANUP_TIMEOUT_MS = 15_000;
 const CODEX_MANAGED_ACCOUNT_LOGIN_TIMEOUT_MS = 10 * 60 * 1000;
 const CODEX_MANAGED_ACCOUNT_CONFIG_OVERRIDES = [
@@ -40,6 +50,8 @@ const CODEX_APP_SERVER_TIMING_TRACE_SCHEMA = 'murph.assistant-codex-app-server-t
 const CODEX_APP_SERVER_TIMING_TRACE_TYPE = 'assistant.codex.app_server_timing';
 const CODEX_TRANSPORT_DIAGNOSTICS_TRACE_SCHEMA = 'murph.assistant-codex-transport-diagnostics.v1';
 const CODEX_TRANSPORT_DIAGNOSTICS_TRACE_TYPE = 'assistant.codex.transport_diagnostics';
+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.
@@ -53,64 +65,56 @@ function prepareCodexRpcParams(method, params) {
     }
     return stripped;
 }
-// Modern app-server clients receive compaction lifecycle as contextCompaction
-// items; `thread/compacted` is the legacy fan-out kept for protocol drift
-// tolerance.
+// Codex emits contextCompaction item lifecycle notifications and also retains
+// the canonical deprecated thread/compacted notification. Both exact pinned
+// protocol shapes are accepted; no dotted or alternate envelope aliases are.
 function isCodexContextCompactionStarted(message) {
-    const method = typeof message.method === 'string' ? message.method : null;
-    if (method !== 'item/started' && method !== 'item.started') {
+    if (message.method !== 'item/started') {
         return false;
     }
-    return asCodexRecord(asCodexRecord(message.params)?.item)?.type === 'contextCompaction';
+    return readCodexRecord(readCodexRecord(message.params)?.item)?.type
+        === 'contextCompaction';
 }
 function readCodexContextCompactionItemId(message) {
-    return normalizeNullableString(asCodexString(asCodexRecord(asCodexRecord(message.params)?.item)?.id));
+    return readCodexNonEmptyString(readCodexRecord(readCodexRecord(message.params)?.item)?.id);
 }
 function isCodexContextCompactionStartedForThread(message, threadId) {
-    if (!isCodexContextCompactionStarted(message)) {
-        return false;
-    }
-    const messageThreadId = extractCodexThreadIdFromMessage(message);
-    return messageThreadId === null || messageThreadId === threadId;
+    return isCodexContextCompactionStarted(message)
+        && extractCodexThreadIdFromMessage(message) === threadId;
 }
 function isCodexLegacyContextCompactionCompletion(message) {
-    const method = typeof message.method === 'string' ? message.method : null;
-    return method === 'thread/compacted' || method === 'thread.compacted';
+    return message.method === 'thread/compacted';
 }
 function isCodexContextCompactionCompletion(message) {
     if (isCodexLegacyContextCompactionCompletion(message)) {
         return true;
     }
-    const method = typeof message.method === 'string' ? message.method : null;
-    if (method !== 'item/completed' && method !== 'item.completed') {
+    if (message.method !== 'item/completed') {
         return false;
     }
-    return asCodexRecord(asCodexRecord(message.params)?.item)?.type === 'contextCompaction';
+    return readCodexRecord(readCodexRecord(message.params)?.item)?.type
+        === 'contextCompaction';
 }
 function isCodexContextCompactionCompletionForThread(message, threadId) {
-    if (!isCodexContextCompactionCompletion(message)) {
-        return false;
-    }
-    const messageThreadId = extractCodexThreadIdFromMessage(message);
-    return messageThreadId === null || messageThreadId === threadId;
+    return isCodexContextCompactionCompletion(message)
+        && extractCodexThreadIdFromMessage(message) === threadId;
 }
 function isCodexThreadTokenUsageUpdatedMethod(method) {
-    return (method === 'thread/tokenUsage/updated' ||
-        method === 'thread/token_usage/updated' ||
-        method === 'thread.tokenUsage.updated' ||
-        method === 'thread.token.usage.updated' ||
-        method === 'thread.token_usage.updated');
+    return method === 'thread/tokenUsage/updated';
 }
 function readCodexThreadTokenUsageUpdate(message) {
-    const method = typeof message.method === 'string' ? message.method : null;
-    if (!isCodexThreadTokenUsageUpdatedMethod(method)) {
+    if (!isCodexThreadTokenUsageUpdatedMethod(readCodexEventMethod(message))) {
         return null;
     }
-    const params = asCodexRecord(message.params);
-    return {
-        last: asCodexRecord(asCodexRecord(params?.tokenUsage)?.last),
-        threadId: typeof params?.threadId === 'string' ? params.threadId : null,
-    };
+    const params = readCodexRecord(message.params);
+    const threadId = readCodexNonEmptyString(params?.threadId);
+    const tokenUsage = readCodexThreadTokenUsage(params?.tokenUsage);
+    return threadId && tokenUsage
+        ? {
+            last: tokenUsage.last,
+            threadId,
+        }
+        : null;
 }
 function buildCodexAppServerNotFoundError(codexCommand) {
     return new VaultCliError('ASSISTANT_CODEX_NOT_FOUND', `Codex app-server executable "${codexCommand}" was not found. Install @openai/codex or pass --codexCommand.`);
@@ -180,51 +184,63 @@ function appendRequiredVaultFileApprovalUrls(message, approvalUrls) {
         ...approvalUrls,
     ].filter((part) => part !== null).join('\n\n');
 }
+function buildRequiredAutomationLocalAtClarificationKey(input) {
+    return `${input.targetKey}:${input.resolvedLocalDate}`;
+}
+function buildRequiredAutomationLocalAtClarification(requirement) {
+    const reminder = `reminder ${JSON.stringify(requirement.targetLabel)}`;
+    return requirement.code === 'local_at_gap'
+        ? `For ${reminder}, the trusted date is ${requirement.resolvedLocalDate}. What other local time on ${requirement.resolvedLocalDate} should I use?`
+        : `For ${reminder}, the trusted date is ${requirement.resolvedLocalDate}. Should I use the earlier or later occurrence on ${requirement.resolvedLocalDate}?`;
+}
+function appendRequiredAutomationLocalAtClarification(message, requirements) {
+    if (requirements.length === 0) {
+        return message;
+    }
+    const normalizedMessage = normalizeNullableString(message);
+    const missingClarifications = requirements
+        .map(buildRequiredAutomationLocalAtClarification)
+        .filter((clarification) => !normalizedMessage?.includes(clarification));
+    return [normalizedMessage, ...missingClarifications]
+        .filter((part) => part !== null)
+        .join('\n\n');
+}
 export async function executeCodexAppServerTurn(input) {
+    const providerStartCriticalPath = stampAssistantProviderStartCriticalPath(input.providerStartCriticalPath, 'codexAppServerTurnStartedAtMonotonicMs');
     assertCodexAppServerPermissionRequest(input);
     const approvalPolicy = resolveSupportedCodexAppServerApprovalPolicy(input.approvalPolicy);
-    const workingDirectory = path.resolve(input.workingDirectory);
-    await assertCodexAppServerWorkingDirectory(workingDirectory);
-    const childEnv = await resolveCodexChildEnv({
-        codexHome: input.codexHome,
-        env: input.env,
-    });
-    const codexCommand = resolveCodexAppServerCommand(input.codexCommand);
+    if (input.processLifetime !== 'one-shot' &&
+        warmCodexWorkspaceBoundaryActive) {
+        throw buildWarmCodexWorkspaceBoundaryBusyError();
+    }
+    const processInput = await prepareCodexAppServerProcessInput(input);
     const tempRoot = await mkdtemp(path.join(tmpdir(), 'murph-codex-'));
-    const imagePaths = await materializeCodexImagePaths({
-        images: input.images,
+    const preparedImages = await materializeCodexImages({
+        images: normalizeCodexAppServerImageDetails({
+            images: input.images,
+            model: input.model,
+            modelProvider: input.modelProvider,
+            turnKind: 'initial',
+        }),
         tempRoot,
     });
     const normalizedInput = {
         ...input,
         approvalPolicy,
-        configOverrides: withHostedCodexModelCatalogConfigOverride({
-            configOverrides: input.configOverrides,
-            env: input.env,
-        }),
+        configOverrides: processInput.configOverrides,
+        ...(providerStartCriticalPath ? { providerStartCriticalPath } : {}),
         runtimeWorkspaceRoots: input.runtimeWorkspaceRoots?.map((root) => path.resolve(root)),
     };
-    const args = buildCodexAppServerArgs(normalizedInput);
-    const launchKey = buildCodexAppServerLaunchKey({
-        args,
-        codexCommand,
-        env: childEnv,
-        workingDirectory,
-    });
     const preparedInput = {
         ...normalizedInput,
-        args,
-        codexCommand,
-        env: childEnv,
+        ...processInput,
         fetchImpl: input.fetchImpl ?? fetch,
         materializeWorkspaceArtifacts: input.materializeWorkspaceArtifacts ?? null,
-        imagePaths,
-        launchKey,
+        preparedImages,
         publicInternetFetch: input.publicInternetFetch ?? null,
         tempRoot,
         voiceMemoRuntime: input.voiceMemoRuntime ?? null,
         askGrokRuntime: input.askGrokRuntime ?? null,
-        workingDirectory,
     };
     let oneShotProcess = null;
     try {
@@ -239,8 +255,20 @@ export async function executeCodexAppServerTurn(input) {
             oneShotProcess.reserveTurn();
             return await runCodexAppServerTurnOnProcess(oneShotProcess, preparedInput);
         }
-        const processInstance = await getOrStartWarmCodexProcess(preparedInput);
-        return await runCodexAppServerTurnOnProcess(processInstance, preparedInput);
+        let allowPreinitializeFallback = true;
+        while (true) {
+            const processInstance = await getOrStartWarmCodexProcess(preparedInput);
+            try {
+                return await runCodexAppServerTurnOnProcess(processInstance, preparedInput);
+            }
+            catch (error) {
+                if (!allowPreinitializeFallback ||
+                    !processInstance.didSpeculativeInitializationFail(error)) {
+                    throw error;
+                }
+                allowPreinitializeFallback = false;
+            }
+        }
     }
     finally {
         try {
@@ -259,14 +287,23 @@ function assertCodexAppServerPermissionRequest(input) {
     if (!permissions) {
         return;
     }
+    const residentWorkspacePermissionRequest = permissions === MURPH_MEMBER_WORKSPACE_PERMISSION_PROFILE;
     const invalidFields = [
         ...(input.sandbox ? ['sandbox'] : []),
-        ...(normalizeNullableString(input.resumeSessionId) ? ['resumeSessionId'] : []),
-        ...(input.ephemeral === true ? [] : ['ephemeral']),
-        ...(input.processLifetime === 'one-shot' ? [] : ['processLifetime']),
+        ...(residentWorkspacePermissionRequest || !normalizeNullableString(input.resumeSessionId)
+            ? []
+            : ['resumeSessionId']),
+        ...(residentWorkspacePermissionRequest || input.ephemeral === true
+            ? []
+            : ['ephemeral']),
+        ...(residentWorkspacePermissionRequest || input.processLifetime === 'one-shot'
+            ? []
+            : ['processLifetime']),
     ];
     if (invalidFields.length > 0) {
-        throw new VaultCliError('ASSISTANT_CODEX_APP_SERVER_REQUEST_INVALID', 'Named Codex permissions require a fresh ephemeral thread in a one-shot process without a legacy sandbox.', {
+        throw new VaultCliError('ASSISTANT_CODEX_APP_SERVER_REQUEST_INVALID', residentWorkspacePermissionRequest
+            ? 'Named Codex permissions cannot be combined with a legacy sandbox.'
+            : 'Restricted named Codex permissions require a fresh ephemeral thread in a one-shot process without a legacy sandbox.', {
             invalidFields,
             retryable: false,
         });
@@ -297,6 +334,38 @@ async function assertCodexAppServerWorkingDirectory(workingDirectory) {
 function resolveCodexAppServerCommand(codexCommand) {
     return codexCommand?.trim() || 'codex';
 }
+async function prepareCodexAppServerProcessInput(input) {
+    const workingDirectory = path.resolve(input.workingDirectory);
+    await assertCodexAppServerWorkingDirectory(workingDirectory);
+    const env = await resolveCodexChildEnv({
+        codexHome: input.codexHome,
+        env: input.env,
+    });
+    const codexCommand = resolveCodexAppServerCommand(input.codexCommand);
+    const configOverrides = withHostedCodexModelCatalogConfigOverride({
+        configOverrides: input.configOverrides,
+        env: input.env,
+    }) ?? [];
+    const args = buildCodexAppServerArgs({
+        configOverrides,
+        oss: input.oss,
+        profile: input.profile,
+    });
+    const launchKey = buildCodexAppServerLaunchKey({
+        args,
+        codexCommand,
+        env,
+        workingDirectory,
+    });
+    return {
+        args,
+        codexCommand,
+        configOverrides,
+        env,
+        launchKey,
+        workingDirectory,
+    };
+}
 function buildCodexAppServerLaunchKey(input) {
     return hashCodexRawString(JSON.stringify({
         args: input.args,
@@ -337,10 +406,14 @@ class CodexAppServerProcess {
     boundThreadModel = null;
     boundThreadServiceTier = null;
     cleanupProcessExitListener;
+    completedTurn = false;
     lastThreadTokenUsage = null;
     codexCommand;
     ignoredResponseIds = new Set();
     initialized = false;
+    initializationFailure = null;
+    initializationPromise = null;
+    initializationWasSpeculative = false;
     endReason = null;
     nextRequestId = 1;
     normalShutdown = false;
@@ -358,6 +431,7 @@ class CodexAppServerProcess {
     stderrBuffer = '';
     startupStderr = '';
     startupFailure = null;
+    spawnReadyPromise = null;
     stdinFailure = null;
     stdoutBuffer = '';
     stopPromise = null;
@@ -408,6 +482,12 @@ class CodexAppServerProcess {
     get initializedForRpc() {
         return this.initialized;
     }
+    get wasPreinitialized() {
+        return this.initializationWasSpeculative;
+    }
+    get hasCompletedTurn() {
+        return this.completedTurn;
+    }
     get processLifetimeMs() {
         return Math.max(0, Date.now() - this.startedAt);
     }
@@ -426,6 +506,32 @@ class CodexAppServerProcess {
     get isStopped() {
         return this.state === 'stopped';
     }
+    get isStoppingOrStopped() {
+        return this.state === 'stopping' || this.state === 'stopped';
+    }
+    get hasUnclaimedSpeculativeInitialization() {
+        return (this.initializationWasSpeculative &&
+            !this.initialized &&
+            !this.hasInFlightTurn);
+    }
+    canClaimForLaunch(launchKey) {
+        return (this.launchKey === launchKey &&
+            !this.poisoned &&
+            this.state === 'idle' &&
+            this.child.exitCode === null &&
+            this.child.signalCode === null);
+    }
+    noteSpeculativeInitialization() {
+        this.initializationWasSpeculative = true;
+    }
+    didSpeculativeInitializationFail(error) {
+        return (this.initializationWasSpeculative &&
+            this.initializationFailure !== null &&
+            this.initializationFailure === error);
+    }
+    noteTurnCompleted() {
+        this.completedTurn = true;
+    }
     reserveTurn() {
         if (this.state !== 'idle' ||
             this.activeTurn ||
@@ -469,6 +575,10 @@ class CodexAppServerProcess {
         });
     }
     async waitForSpawn() {
+        this.spawnReadyPromise ??= this.runWaitForSpawn();
+        await this.spawnReadyPromise;
+    }
+    async runWaitForSpawn() {
         this.throwStartupFailure();
         try {
             await waitForCodexSpawn(this.child);
@@ -482,9 +592,18 @@ class CodexAppServerProcess {
         this.throwStartupFailure();
     }
     async initialize() {
-        if (this.initialized) {
-            return;
-        }
+        this.initializationPromise ??= this.runInitialize().catch((error) => {
+            this.initializationFailure = error;
+            this.poisoned = true;
+            if (error instanceof Error) {
+                this.startupFailure ??= error;
+            }
+            throw error;
+        });
+        await this.initializationPromise;
+    }
+    async runInitialize() {
+        await this.waitForSpawn();
         await withCodexRpcTimeout(this.sendRequest('initialize', {
             clientInfo: {
                 name: CODEX_RPC_CLIENT_NAME,
@@ -569,7 +688,8 @@ class CodexAppServerProcess {
             !this.poisoned &&
             this.child.exitCode === null &&
             this.child.signalCode === null &&
-            this.state === 'idle') {
+            (this.state === 'idle' ||
+                (this.state === 'reserved' && this.activeTurn === null))) {
             return;
         }
         throw new VaultCliError('ASSISTANT_CODEX_BACKGROUND_WORK_UNAVAILABLE', 'Codex app-server background work could not be verified before the workspace boundary.', { retryable: true });
@@ -690,6 +810,10 @@ class CodexAppServerProcess {
         this.endReason ??= resolveCodexAppServerEndReason(reason);
         this.normalShutdown = true;
         this.state = 'stopping';
+        this.rejectPending(new VaultCliError('ASSISTANT_CODEX_APP_SERVER_STOPPED', 'Codex app-server stopped before its pending RPC completed.', {
+            reason,
+            retryable: true,
+        }));
         let stopped = false;
         try {
             await stopCodexAppServerChild({
@@ -722,12 +846,9 @@ class CodexAppServerProcess {
         await this.stop(reason).catch(() => undefined);
     }
     isReusableFor(launchKey) {
-        return (this.launchKey === launchKey &&
+        return (this.canClaimForLaunch(launchKey) &&
             this.initialized &&
-            !this.poisoned &&
-            this.state === 'idle' &&
-            this.child.exitCode === null &&
-            this.child.signalCode === null);
+            this.initializationFailure === null);
     }
     closeStdin() {
         if (this.stdinFailure) {
@@ -943,6 +1064,7 @@ class CodexAppServerProcess {
         this.state = 'stopped';
         this.cleanupProcessExitListener();
         if (this.normalShutdown) {
+            this.rejectPending(new VaultCliError('ASSISTANT_CODEX_APP_SERVER_STOPPED', 'Codex app-server closed before its pending RPC completed.', { retryable: true }));
             return;
         }
         if (this.activeTurn) {
@@ -1018,7 +1140,7 @@ function readCodexBackgroundTerminalPresence(value) {
 }
 function readCodexSubagentActivity(message) {
     const method = typeof message.method === 'string' ? message.method : null;
-    if (method !== 'item/completed' && method !== 'item.completed') {
+    if (method !== 'item/completed') {
         return null;
     }
     const item = asCodexRecord(asCodexRecord(message.params)?.item);
@@ -1109,6 +1231,13 @@ function resolveCodexAppServerEndReason(reason) {
 }
 let warmCodexProcess = null;
 let warmCodexSlotLock = Promise.resolve();
+let warmCodexWorkspaceBoundaryActive = false;
+function buildWarmCodexWorkspaceBoundaryBusyError() {
+    return new VaultCliError('ASSISTANT_CODEX_APP_SERVER_BUSY', 'Codex app-server cannot be claimed while a workspace boundary is active.', {
+        retryable: true,
+        state: 'workspace-boundary',
+    });
+}
 async function withWarmCodexSlotLock(operation) {
     const previous = warmCodexSlotLock;
     let release;
@@ -1124,15 +1253,17 @@ async function withWarmCodexSlotLock(operation) {
     }
 }
 async function getOrStartWarmCodexProcess(input) {
+    if (warmCodexWorkspaceBoundaryActive) {
+        throw buildWarmCodexWorkspaceBoundaryBusyError();
+    }
     const launchKey = input.launchKey;
     return await withWarmCodexSlotLock(async () => {
-        if (warmCodexProcess?.isReusableFor(launchKey)) {
-            warmCodexProcess.reserveTurn();
-            return warmCodexProcess;
-        }
         const previousProcess = warmCodexProcess;
-        let coldStartReason = 'node-process-first-use';
         if (previousProcess) {
+            if (previousProcess.canClaimForLaunch(launchKey)) {
+                previousProcess.reserveTurn();
+                return previousProcess;
+            }
             if (previousProcess.hasInFlightTurn) {
                 throw previousProcess.buildBusyError('Codex app-server process is already serving a turn.');
             }
@@ -1144,15 +1275,121 @@ async function getOrStartWarmCodexProcess(input) {
                     ? 'launch-identity-changed'
                     : 'process-unhealthy';
             await previousProcess.stop(stopReason);
-            coldStartReason = previousProcess.nextColdStartReason;
         }
         const processInstance = new CodexAppServerProcess({
             ...input,
-            coldStartReason,
+            coldStartReason: previousProcess?.nextColdStartReason ?? 'node-process-first-use',
         });
         warmCodexProcess = processInstance;
-        warmCodexProcess.reserveTurn();
-        return warmCodexProcess;
+        processInstance.reserveTurn();
+        return processInstance;
+    });
+}
+async function stopExactUnclaimedWarmCodexProcess(processInstance, reason) {
+    await withWarmCodexSlotLock(async () => {
+        if (warmCodexProcess !== processInstance ||
+            !processInstance.hasUnclaimedSpeculativeInitialization) {
+            return;
+        }
+        await processInstance.stop(reason);
+    });
+}
+function createCodexAppServerPreinitialization(processInstance) {
+    return {
+        async cancelPending() {
+            try {
+                await stopExactUnclaimedWarmCodexProcess(processInstance, 'invocation-release-during-preinitialize');
+            }
+            catch (error) {
+                // An already-proven exit is sufficient for this optional optimization's
+                // invocation-release boundary. Unproven teardown still fails closed.
+                if (!processInstance.isStopped) {
+                    throw error;
+                }
+            }
+        },
+    };
+}
+function readCodexPreinitializeAbortReason(signal) {
+    return signal.reason instanceof Error
+        ? signal.reason
+        : new DOMException('Codex app-server preinitialization was interrupted.', 'AbortError');
+}
+function beginCodexPreinitialize(processInstance, signal) {
+    const readiness = processInstance.initialize();
+    const onAbort = () => {
+        void stopExactUnclaimedWarmCodexProcess(processInstance, 'preinitialize-aborted').catch(() => undefined);
+    };
+    signal?.addEventListener('abort', onAbort, { once: true });
+    if (signal?.aborted) {
+        onAbort();
+    }
+    void readiness.then(() => {
+        signal?.removeEventListener('abort', onAbort);
+    }, () => {
+        signal?.removeEventListener('abort', onAbort);
+        if (processInstance.isStoppingOrStopped) {
+            return;
+        }
+        void stopExactUnclaimedWarmCodexProcess(processInstance, 'preinitialize-failure').catch(() => undefined);
+    });
+}
+export async function preinitializeCodexAppServer(input) {
+    const signal = input.signal ?? null;
+    if (signal?.aborted) {
+        throw readCodexPreinitializeAbortReason(signal);
+    }
+    if (warmCodexWorkspaceBoundaryActive) {
+        return null;
+    }
+    const processInput = await prepareCodexAppServerProcessInput(input);
+    if (signal?.aborted) {
+        throw readCodexPreinitializeAbortReason(signal);
+    }
+    if (warmCodexWorkspaceBoundaryActive) {
+        return null;
+    }
+    return await withWarmCodexSlotLock(async () => {
+        if (signal?.aborted) {
+            throw readCodexPreinitializeAbortReason(signal);
+        }
+        const processInstance = warmCodexProcess;
+        if (processInstance) {
+            if (processInstance.canClaimForLaunch(processInput.launchKey)) {
+                if (!processInstance.initializedForRpc) {
+                    processInstance.noteSpeculativeInitialization();
+                    beginCodexPreinitialize(processInstance, signal);
+                }
+                return createCodexAppServerPreinitialization(processInstance);
+            }
+            if (processInstance.hasInFlightTurn) {
+                return null;
+            }
+            if (processInstance.canClaimForLaunch(processInstance.launchKey)) {
+                return null;
+            }
+            const processExited = processInstance.child.exitCode !== null ||
+                processInstance.child.signalCode !== null;
+            await processInstance.stop(processExited
+                ? 'process-exited'
+                : processInstance.launchKey !== processInput.launchKey
+                    ? 'launch-identity-changed'
+                    : 'process-unhealthy');
+        }
+        if (signal?.aborted) {
+            throw readCodexPreinitializeAbortReason(signal);
+        }
+        const preparedProcess = new CodexAppServerProcess({
+            args: processInput.args,
+            codexCommand: processInput.codexCommand,
+            coldStartReason: processInstance?.nextColdStartReason ?? 'node-process-first-use',
+            env: processInput.env,
+            launchKey: processInput.launchKey,
+        });
+        preparedProcess.noteSpeculativeInitialization();
+        warmCodexProcess = preparedProcess;
+        beginCodexPreinitialize(preparedProcess, signal);
+        return createCodexAppServerPreinitialization(preparedProcess);
     });
 }
 export async function stopWarmCodexAppServer(reason = 'external-stop') {
@@ -1168,13 +1405,43 @@ export async function stopWarmCodexAppServer(reason = 'external-stop') {
     });
 }
 export async function waitForWarmCodexBackgroundWork(input = {}) {
-    await withWarmCodexSlotLock(async () => {
-        const processInstance = warmCodexProcess;
-        if (!processInstance || processInstance.isStopped) {
+    if (warmCodexWorkspaceBoundaryActive) {
+        throw buildWarmCodexWorkspaceBoundaryBusyError();
+    }
+    warmCodexWorkspaceBoundaryActive = true;
+    try {
+        const processInstance = await withWarmCodexSlotLock(async () => {
+            const processInstance = warmCodexProcess;
+            if (!processInstance || processInstance.isStopped) {
+                return null;
+            }
+            if (processInstance.hasUnclaimedSpeculativeInitialization) {
+                await processInstance.stop('workspace-boundary-during-preinitialize');
+                return null;
+            }
+            if (processInstance.hasInFlightTurn) {
+                throw processInstance.buildBusyError('Codex app-server process is serving a turn and cannot cross a workspace boundary.');
+            }
+            if (!processInstance.isReusableFor(processInstance.launchKey)) {
+                await processInstance.stop('workspace-boundary-process-unhealthy');
+                return null;
+            }
+            processInstance.reserveTurn();
+            return processInstance;
+        });
+        if (!processInstance) {
             return;
         }
-        await processInstance.waitForBackgroundWork(input);
-    });
+        try {
+            await processInstance.waitForBackgroundWork(input);
+        }
+        finally {
+            processInstance.releaseReservation();
+        }
+    }
+    finally {
+        warmCodexWorkspaceBoundaryActive = false;
+    }
 }
 registerStopWarmCodexAppServer(stopWarmCodexAppServer);
 registerWaitForWarmCodexBackgroundWork(waitForWarmCodexBackgroundWork);
@@ -1185,6 +1452,9 @@ registerWaitForWarmCodexBackgroundWork(waitForWarmCodexBackgroundWork);
  * process may write CODEX_HOME at a time.
  */
 export async function executeCodexManagedAccountOperation(input) {
+    if (warmCodexWorkspaceBoundaryActive) {
+        throw buildWarmCodexWorkspaceBoundaryBusyError();
+    }
     const workingDirectory = path.resolve(input.workingDirectory);
     await assertCodexAppServerWorkingDirectory(workingDirectory);
     const env = await resolveCodexChildEnv({
@@ -1405,63 +1675,6 @@ function estimateCodexWarmThreadCompactionUsage(threadContextTokensBefore) {
         totalTokens: threadContextTokensBefore,
     };
 }
-function readCodexCompactionCompletionProviderUsage(message, threadId) {
-    if (!isCodexContextCompactionCompletionForThread(message, threadId)) {
-        return null;
-    }
-    const params = asCodexRecord(message.params);
-    const item = asCodexRecord(params?.item);
-    const candidates = [
-        ...readCodexProviderUsageCandidates(params),
-        ...readCodexProviderUsageCandidates(item),
-    ];
-    for (const candidate of candidates) {
-        const usage = readCodexCompactionProviderUsage(candidate);
-        if (usage) {
-            return usage;
-        }
-    }
-    return null;
-}
-function readCodexProviderUsageCandidates(value) {
-    if (!value) {
-        return [];
-    }
-    const providerUsage = asCodexRecord(value.providerUsage)
-        ?? asCodexRecord(value.provider_usage);
-    return [providerUsage, asCodexRecord(providerUsage?.last)];
-}
-function readCodexCompactionProviderUsage(value) {
-    if (!value) {
-        return null;
-    }
-    const inputTokens = readCodexUsageNumber(value, 'inputTokens', 'input_tokens');
-    const outputTokens = readCodexUsageNumber(value, 'outputTokens', 'output_tokens');
-    const totalTokens = readCodexUsageNumber(value, 'totalTokens', 'total_tokens');
-    if (inputTokens === null || outputTokens === null || totalTokens === null) {
-        return null;
-    }
-    if (inputTokens <= 0 || outputTokens < 0 || totalTokens < inputTokens + outputTokens) {
-        return null;
-    }
-    const cachedInputTokens = readCodexUsageNumber(value, 'cachedInputTokens', 'cached_input_tokens');
-    if (cachedInputTokens !== null && cachedInputTokens > inputTokens) {
-        return null;
-    }
-    return {
-        cachedInputTokens,
-        inputTokens,
-        outputTokens,
-        source: 'provider',
-        totalTokens,
-    };
-}
-function readCodexUsageNumber(value, camelKey, snakeKey) {
-    const raw = value[camelKey] ?? value[snakeKey];
-    return typeof raw === 'number' && Number.isSafeInteger(raw) && raw >= 0
-        ? raw
-        : null;
-}
 // Non-turn compaction of the warm Codex thread, for idle-time maintenance.
 // Modeled on the other warm-slot lifecycle exports above. Failure handling is
 // deliberately blunt: any non-success poisons (kills) the warm process. A
@@ -1509,7 +1722,11 @@ export async function compactWarmCodexThread(input) {
             };
         }
         processInstance.reserveTurn();
-        return { kind: 'reserved', processInstance, vitals };
+        return {
+            kind: 'reserved',
+            processInstance,
+            vitals,
+        };
     });
     if (reservation.kind !== 'reserved') {
         return reservation;
@@ -1520,7 +1737,6 @@ export async function compactWarmCodexThread(input) {
     let compactRequestAccepted = false;
     let compactStartedItemId = null;
     let compactCompletionBuffered = false;
-    let providerUsage = null;
     let compactionSettleReason = null;
     let resolveCompaction;
     const compactionSettled = new Promise((resolve) => {
@@ -1591,8 +1807,6 @@ export async function compactWarmCodexThread(input) {
                 if (!compactRequestAccepted) {
                     return;
                 }
-                providerUsage = readCodexCompactionCompletionProviderUsage(message, vitals.threadId)
-                    ?? providerUsage;
                 settleCompaction('compacted');
                 return;
             }
@@ -1605,8 +1819,6 @@ export async function compactWarmCodexThread(input) {
                 if (compactStartedItemId === null || itemId !== compactStartedItemId) {
                     return;
                 }
-                providerUsage = readCodexCompactionCompletionProviderUsage(message, vitals.threadId)
-                    ?? providerUsage;
                 if (compactRequestAccepted) {
                     settleCompaction('compacted');
                 }
@@ -1658,8 +1870,7 @@ export async function compactWarmCodexThread(input) {
                 threadContextTokensBefore: vitals.lastInputTokens,
                 threadId: vitals.threadId,
                 serviceTier: vitals.serviceTier,
-                usage: providerUsage
-                    ?? estimateCodexWarmThreadCompactionUsage(vitals.lastInputTokens),
+                usage: estimateCodexWarmThreadCompactionUsage(vitals.lastInputTokens),
             };
         }
         await processInstance.poison('idle-compaction-failed');
@@ -1694,19 +1905,16 @@ function hashCodexRawString(value) {
         .digest('hex');
 }
 function readCodexEventMethod(message) {
-    return typeof message.method === 'string'
-        ? message.method
-        : typeof message.type === 'string'
-            ? message.type
-            : typeof message.event === 'string'
-                ? message.event
-                : null;
+    return typeof message.method === 'string' ? message.method : null;
 }
 function isCodexTurnStartedMethod(method) {
-    return method === 'turn/started' || method === 'turn.started';
+    return method === 'turn/started';
+}
+function createCodexSubagentTurnUsageKey(input) {
+    return `${input.threadId}\u0000${input.turnId}`;
 }
 function isCodexTurnCompletedMethod(method) {
-    return method === 'turn/completed' || method === 'turn.completed';
+    return method === 'turn/completed';
 }
 function buildCodexTransportDiagnosticsTraceEvent(input) {
     const source = readCodexTransportDiagnosticSource(input.message, input.method);
@@ -1839,6 +2047,7 @@ function readCodexDynamicToolKey(message) {
     return namespace && tool ? `${namespace}.${tool}` : null;
 }
 async function runCodexAppServerTurnOnProcess(codexProcess, input) {
+    const providerStartCriticalPath = stampAssistantProviderStartCriticalPath(input.providerStartCriticalPath, 'codexAppServerProcessTurnStartedAtMonotonicMs');
     const hostedCanonicalWritePort = readHostedCanonicalWritePort();
     let stdout = '';
     let stderr = '';
@@ -1851,7 +2060,7 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
     const offeredDynamicToolKeys = new Set(input.dynamicTools.map((tool) => `${tool.namespace}.${tool.name}`));
     let codexThreadId = null;
     let turnId = null;
-    const isReusedWarmProcess = codexProcess.initializedForRpc;
+    const isReusedWarmProcess = codexProcess.hasCompletedTurn;
     // Completed final-phase agent messages that were followed by a steered
     // user-message item and then superseded by a newer response segment in the
     // same turn. A closed segment is held as a candidate until newer text or
@@ -1865,6 +2074,8 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
     let lastEventError = null;
     let lastEventErrorInfo = null;
     let responseMedia = [];
+    let responseCard = null;
+    let responseCardTextFallback = null;
     const assistantStyleSettingsOverlay = {
         settings: {},
     };
@@ -1879,7 +2090,25 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
     // Trusted turn-scoped murph.ask_grok provider-call ceiling: one counter per
     // assistant turn, owned here and threaded into the dynamic-tool executor.
     const askGrokTurnState = createAskGrokTurnState();
-    const subagentTokenUsageByThread = new Map();
+    const groupSharedReadTurnState = {
+        currentSenderDecisionByMessageRef: new Map(),
+        invalid: false,
+        readProjectionScopeKeyBatches: [],
+        roster: null,
+    };
+    const automationRelativeDateReferenceWindows = [
+        input.automationRelativeDateReferenceWindow
+            ? { ...input.automationRelativeDateReferenceWindow }
+            : null,
+    ];
+    const generateSongTurnState = input.generateSongPolicy
+        ? {
+            attemptCount: 0,
+            policy: input.generateSongPolicy,
+        }
+        : 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.
@@ -1889,8 +2118,10 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
     const providerActionItemIds = new Set();
     const jsonEvents = [];
     const runtimeIssueInputs = [];
+    const actionRuntimeIssueTracker = createCodexActionRuntimeIssueTracker();
     let computerToolsLockedAfterUserPause = false;
     const requiredVaultFileApprovalUrls = [];
+    const requiredAutomationLocalAtClarifications = new Map();
     const actionDiagnostics = input.onTraceEvent
         ? createCodexActionDiagnosticsReducer()
         : null;
@@ -1907,7 +2138,9 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
     let codexTimingTurnStartAckElapsedMs = null;
     let codexTimingTurnStartedNotificationElapsedMs = null;
     let codexTimingTurnCompletedNotificationElapsedMs = null;
+    let currentTurnStartedNotificationObserved = false;
     let liveInterruptRequested = false;
+    let terminalNoReplyInterruptRequested = false;
     let completeTurn = null;
     let failTurn = null;
     let liveTurnOpen = false;
@@ -1916,6 +2149,7 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
     let contextCompactionProgressNotified = false;
     let contextCompactionProgressPending = false;
     let releaseLiveTurn = () => { };
+    const pendingDynamicToolRequests = new Set();
     const pendingProgressDeliveries = new Set();
     let dynamicToolExecutionChain = Promise.resolve();
     const dynamicToolAbortController = new AbortController();
@@ -1970,13 +2204,15 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
         parentModel: normalizeNullableString(input.model) ?? null,
         parentRawEvents: jsonEvents,
         serviceTier: input.serviceTier ?? null,
-        subagentTokenUsageByThread,
+        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 || requiredVaultFileApprovalUrls.length > 0;
+    const hasRequiredUserVisibleOutput = () => computerToolsLockedAfterUserPause ||
+        requiredAutomationLocalAtClarifications.size > 0 ||
+        requiredVaultFileApprovalUrls.length > 0;
     const settleNoReplyFinalActions = async () => {
         if (hasRequiredUserVisibleOutput() || noReplySettlementStarted) {
             return;
@@ -2083,7 +2319,7 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
                 rawEvent: {
                     schema: CODEX_APP_SERVER_TIMING_TRACE_SCHEMA,
                     type: CODEX_APP_SERVER_TIMING_TRACE_TYPE,
-                    ...(stage === 'initialized'
+                    ...(stage === 'initialized' || stage === 'preinitialized'
                         ? {
                             codexTimingColdStartReason: codexProcess.coldStartReason,
                         }
@@ -2269,22 +2505,48 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
         if (!trailingSteerCandidate) {
             return;
         }
-        precedingAgentMessageSegments.push(trailingSteerCandidate);
+        const response = trailingSteerCandidate.card
+            ? renderAssistantResponseCardText(trailingSteerCandidate.card)
+            : trailingSteerCandidate.cardTextFallback
+                ? renderAssistantWorkoutResponseCardText(trailingSteerCandidate.cardTextFallback)
+                : trailingSteerCandidate.response;
+        const transcriptResponse = trailingSteerCandidate.card
+            ? renderAssistantResponseCardTranscriptText(trailingSteerCandidate.card)
+            : trailingSteerCandidate.cardTextFallback
+                ? renderAssistantWorkoutResponseCardTranscriptText(trailingSteerCandidate.cardTextFallback)
+                : response;
+        precedingAgentMessageSegments.push({
+            deliveryContextOrdinal: trailingSteerCandidate.deliveryContextOrdinal,
+            media: [...trailingSteerCandidate.media],
+            response,
+            ...(transcriptResponse === response ? {} : { transcriptResponse }),
+            ...(trailingSteerCandidate.targetInputId
+                ? { targetInputId: trailingSteerCandidate.targetInputId }
+                : {}),
+        });
         trailingSteerCandidate = null;
     };
-    const notifyProviderRequestStarted = () => {
+    const notifyProviderRequestStarted = (providedStartedAtMonotonicMs) => {
         if (providerRequestStartedNotified) {
             return;
         }
         providerRequestStartedNotified = true;
+        const providerStartedAtMonotonicMs = providedStartedAtMonotonicMs
+            ?? readAssistantProviderStartMonotonicTickMs();
         const startedAtMs = Date.now();
         codexProviderRequestStartedAtMs = startedAtMs;
+        const completedProviderStartCriticalPath = input.providerRequestOrdinal === 0
+            ? completeAssistantProviderStartCriticalPath(providerStartCriticalPath, providerStartedAtMonotonicMs)
+            : null;
         notifyCodexAppServerProviderRequestStartedBestEffort({
             hook: input.onProviderRequestStarted ?? null,
             startedAt: new Date(startedAtMs).toISOString(),
             timing: {
                 ...codexAppServerProviderStartTiming,
                 codexAppServerPreProviderMs: Math.max(0, startedAtMs - codexAppServerTurnStartedAt),
+                ...(completedProviderStartCriticalPath
+                    ? { providerStartCriticalPath: completedProviderStartCriticalPath }
+                    : {}),
             },
         });
     };
@@ -2312,6 +2574,7 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
         try {
             contextCompactionProgressPending = true;
             progressPromise = progressDelivery.send(text, {
+                deliveryContextOrdinal,
                 required: true,
                 source: 'system',
             });
@@ -2346,6 +2609,21 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
         });
         pendingProgressDeliveries.add(tracked);
     };
+    const trackDynamicToolRequest = (promise) => {
+        const tracked = promise
+            .catch((error) => {
+            rejectOnce(error);
+        })
+            .finally(() => {
+            pendingDynamicToolRequests.delete(tracked);
+        });
+        pendingDynamicToolRequests.add(tracked);
+    };
+    const drainPendingDynamicToolRequests = async () => {
+        while (pendingDynamicToolRequests.size > 0) {
+            await Promise.all([...pendingDynamicToolRequests]);
+        }
+    };
     const drainPendingProgressDeliveries = async () => {
         while (pendingProgressDeliveries.size > 0) {
             await waitForCodexProgressDrain([
@@ -2376,9 +2654,60 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
         if (hasAcceptedNoReplyPatchForDeliveryContext(deliveryContextOrdinal)) {
             throw new VaultCliError('ASSISTANT_RESPONSE_MEDIA_AFTER_NO_REPLY', 'Response media cannot be attached after finish_without_reply.');
         }
-        responseMedia = patch.op === 'replace'
+        const nextMedia = patch.op === 'replace'
             ? patch.media
             : normalizeAssistantResponseMediaList([...responseMedia, ...patch.media]);
+        if (nextMedia.length > ASSISTANT_AUTHORED_RESPONSE_MEDIA_MAX_ITEMS) {
+            throw new VaultCliError('ASSISTANT_RESPONSE_MEDIA_LIMIT_EXCEEDED', `Assistant responses may attach at most ${ASSISTANT_AUTHORED_RESPONSE_MEDIA_MAX_ITEMS} media items.`);
+        }
+        if (responseCard !== null && nextMedia.length > 0) {
+            throw new VaultCliError('ASSISTANT_RESPONSE_CARD_MEDIA_CONFLICT', 'Response media cannot be combined with a response card.');
+        }
+        if (responseCardTextFallback !== null && nextMedia.length > 0) {
+            throw new VaultCliError('ASSISTANT_RESPONSE_CARD_MEDIA_CONFLICT', 'Response media cannot be combined with response card text recovery.');
+        }
+        responseMedia = nextMedia;
+    };
+    const applyResponseCardPatch = (card, deliveryContextOrdinal) => {
+        if (deliveryContextOrdinal !== 0 ||
+            currentDeliveryContextOrdinal() !== deliveryContextOrdinal) {
+            throw new VaultCliError('ASSISTANT_RESPONSE_CARD_CONTEXT_ADVANCED', 'A response card cannot attach after accepted input advances the response context.');
+        }
+        if (hasAcceptedNoReplyPatchForDeliveryContext(deliveryContextOrdinal)) {
+            throw new VaultCliError('ASSISTANT_RESPONSE_CARD_AFTER_NO_REPLY', 'A response card cannot be attached after finish_without_reply.');
+        }
+        if (responseCard !== null) {
+            throw new VaultCliError('ASSISTANT_RESPONSE_CARD_LIMIT_REACHED', 'Only one response card may be attached to a final response.');
+        }
+        if (responseCardTextFallback !== null) {
+            throw new VaultCliError('ASSISTANT_RESPONSE_CARD_LIMIT_REACHED', 'Only one response card outcome may be attached to a final response.');
+        }
+        if (responseMedia.length > 0) {
+            throw new VaultCliError('ASSISTANT_RESPONSE_CARD_MEDIA_CONFLICT', 'A response card cannot be combined with response media.');
+        }
+        if (requiredVaultFileApprovalUrls.length > 0) {
+            throw new VaultCliError('ASSISTANT_RESPONSE_CARD_VAULT_FILE_CONFLICT', 'A response card cannot replace a required vault-file approval link.');
+        }
+        responseCard = card;
+    };
+    const applyResponseCardTextFallbackPatch = (card, deliveryContextOrdinal) => {
+        if (deliveryContextOrdinal !== 0 ||
+            currentDeliveryContextOrdinal() !== deliveryContextOrdinal) {
+            throw new VaultCliError('ASSISTANT_RESPONSE_CARD_CONTEXT_ADVANCED', 'Response card text recovery cannot attach after accepted input advances the response context.');
+        }
+        if (hasAcceptedNoReplyPatchForDeliveryContext(deliveryContextOrdinal)) {
+            throw new VaultCliError('ASSISTANT_RESPONSE_CARD_AFTER_NO_REPLY', 'Response card text recovery cannot attach after finish_without_reply.');
+        }
+        if (responseCard !== null || responseCardTextFallback !== null) {
+            throw new VaultCliError('ASSISTANT_RESPONSE_CARD_LIMIT_REACHED', 'Only one response card outcome may be attached to a final response.');
+        }
+        if (responseMedia.length > 0) {
+            throw new VaultCliError('ASSISTANT_RESPONSE_CARD_MEDIA_CONFLICT', 'Response card text recovery cannot be combined with response media.');
+        }
+        if (requiredVaultFileApprovalUrls.length > 0) {
+            throw new VaultCliError('ASSISTANT_RESPONSE_CARD_VAULT_FILE_CONFLICT', 'Response card text recovery cannot replace a required vault-file approval link.');
+        }
+        responseCardTextFallback = card;
     };
     const canApplyNoReplyPatch = (deliveryContextOrdinal) => {
         const trailingSteerCandidateOrdinal = trailingSteerCandidate?.deliveryContextOrdinal;
@@ -2393,6 +2722,12 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
         if (responseMedia.length > 0) {
             return false;
         }
+        if (responseCard !== null) {
+            return false;
+        }
+        if (responseCardTextFallback !== null) {
+            return false;
+        }
         if (precedingAgentMessageSegments.some((segment) => segment.deliveryContextOrdinal < deliveryContextOrdinal)) {
             return false;
         }
@@ -2451,6 +2786,17 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
         reservedNoReplyDeliveryContextOrdinals.delete(deliveryContextOrdinal);
         return true;
     };
+    const applyTerminalExternalEffectNoReplyPatch = (patch, deliveryContextOrdinal) => {
+        // A host-authorized external effect has crossed its delivery boundary.
+        // Its terminal disposition is not a model-requested finish_without_reply
+        // and must not depend on trace callback visibility.
+        finalActionPatches = [
+            ...finalActionPatches.filter((action) => action.deliveryContextOrdinal !== deliveryContextOrdinal),
+            { deliveryContextOrdinal, patch },
+        ];
+        replyTargetPatches = replyTargetPatches.filter((entry) => entry.deliveryContextOrdinal !== deliveryContextOrdinal);
+        reservedNoReplyDeliveryContextOrdinals.delete(deliveryContextOrdinal);
+    };
     const resolveFinalActionPatch = (deliveryContextOrdinal) => finalActionPatches.find((action) => action.deliveryContextOrdinal === deliveryContextOrdinal)?.patch ?? null;
     const resolveReplyTargetPatch = (deliveryContextOrdinal) => replyTargetPatches.find((entry) => entry.deliveryContextOrdinal === deliveryContextOrdinal)?.patch ?? null;
     const shouldSuppressDeliveryContext = (deliveryContextOrdinal) => {
@@ -2463,7 +2809,7 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
     const acceptJsonEvent = (message) => {
         jsonEvents.push(message);
     };
-    const handleAcceptedServerRequest = (message, requestId) => {
+    const handleAcceptedServerRequest = async (message, requestId) => {
         acceptJsonEvent(message);
         if (turnTerminal) {
             void tryWriteRpcMessage({
@@ -2480,7 +2826,40 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             });
             return;
         }
-        const dynamicToolRequest = readMurphDynamicToolRequest(message);
+        if (message.method !== 'item/tool/call') {
+            denyUnsupportedCodexServerRequest({
+                message,
+                requestId,
+                writeRpcMessage: (payload) => {
+                    void tryWriteRpcMessage(payload);
+                },
+            });
+            return;
+        }
+        const dynamicToolRequestDeliveryContextOrdinal = currentDeliveryContextOrdinal();
+        let dynamicToolRuntime;
+        try {
+            dynamicToolRuntime = await loadMurphDynamicToolRuntime();
+        }
+        catch {
+            void tryWriteRpcMessage({
+                id: requestId,
+                error: {
+                    code: -32000,
+                    message: 'Dynamic tool runtime is unavailable.',
+                },
+            });
+            return;
+        }
+        const { claimCurrentSenderTurnDecision, executeMurphDynamicToolRequest, isComputerDynamicToolRequest, readMurphDynamicToolRequest, } = dynamicToolRuntime;
+        const dynamicToolRequest = readMurphDynamicToolRequest(message, {
+            automationRelativeDateReferenceWindow: automationRelativeDateReferenceWindows[dynamicToolRequestDeliveryContextOrdinal] ?? null,
+            responseCardAudience: input.groupConversation === true
+                ? 'group'
+                : input.groupConversation === false
+                    ? 'private'
+                    : null,
+        });
         if (!dynamicToolRequest) {
             denyUnsupportedCodexServerRequest({
                 message,
@@ -2543,6 +2922,26 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
                 reason: 'invalid_arguments',
             }));
         }
+        const currentSenderDecisionClaim = claimCurrentSenderTurnDecision({
+            request: dynamicToolRequest,
+            turnState: groupSharedReadTurnState,
+        });
+        if (currentSenderDecisionClaim === 'conflict'
+            || currentSenderDecisionClaim === 'unavailable') {
+            void tryWriteRpcMessage({
+                id: requestId,
+                result: {
+                    success: false,
+                    contentItems: [{
+                            type: 'inputText',
+                            text: currentSenderDecisionClaim === 'conflict'
+                                ? 'current-sender request conflicts with an earlier decision for this Message'
+                                : 'current-sender decision authority is unavailable for this turn',
+                        }],
+                },
+            });
+            return;
+        }
         if (input.allowFinishWithoutReply === false &&
             (dynamicToolRequest.kind === 'finish-without-reply' ||
                 dynamicToolRequest.kind === 'invalid-finish-without-reply-arguments')) {
@@ -2608,7 +3007,6 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             });
             return;
         }
-        const dynamicToolRequestDeliveryContextOrdinal = currentDeliveryContextOrdinal();
         const dynamicToolDeliveryContextOrdinal = dynamicToolRequest.kind === 'finish-without-reply' ||
             dynamicToolRequest.kind === 'react-to-message' ||
             dynamicToolRequest.kind === 'select-reply-target' ||
@@ -2668,6 +3066,7 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             computerToolsLockedAfterUserPause = true;
             closeLiveTurn();
         }
+        let dynamicToolRequestSettled = false;
         const runDynamicTool = () => withHostedCanonicalWritePort(hostedCanonicalWritePort, async () => {
             const existingFinalAction = resolveFinalActionPatch(dynamicToolRequestDeliveryContextOrdinal);
             const vaultFileOwnsFinalAction = existingFinalAction?.kind === 'none' &&
@@ -2676,7 +3075,7 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
                 !vaultFileOwnsFinalAction;
             if (shouldSuppressDeliveryContext(dynamicToolRequestDeliveryContextOrdinal) &&
                 !vaultFileMayClassifyAfterGenericNoReply &&
-                isResponseMediaDynamicToolRequest(dynamicToolRequest)) {
+                isResponseAttachmentDynamicToolRequest(dynamicToolRequest)) {
                 return {
                     rpcResult: {
                         contentItems: [{
@@ -2692,7 +3091,65 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
                 };
             }
             const hostedToolContext = resolveCodexAppServerHostedToolContext(input);
-            await hostedToolContext?.beforeToolExecution?.();
+            await hostedToolContext?.beforeToolExecution?.(dynamicToolRequestDeliveryContextOrdinal);
+            let requestedLocalAtRecovery = null;
+            if ((dynamicToolRequest.kind === 'automation' ||
+                dynamicToolRequest.kind === 'invalid-automation-arguments') &&
+                dynamicToolRequest.localAtRecovery) {
+                requestedLocalAtRecovery = dynamicToolRequest.localAtRecovery;
+            }
+            else if (dynamicToolRequest.kind ===
+                'automation-local-at-recovery-dismissal') {
+                requestedLocalAtRecovery = {
+                    recoveryKey: dynamicToolRequest.recoveryKey,
+                    resolvedLocalDate: dynamicToolRequest.resolvedLocalDate,
+                };
+            }
+            if (requestedLocalAtRecovery) {
+                const clarificationKey = buildRequiredAutomationLocalAtClarificationKey({
+                    resolvedLocalDate: requestedLocalAtRecovery.resolvedLocalDate,
+                    targetKey: requestedLocalAtRecovery.recoveryKey,
+                });
+                if (!requiredAutomationLocalAtClarifications.has(clarificationKey)) {
+                    return {
+                        rpcResult: {
+                            contentItems: [{
+                                    text: 'local-time recovery key or trusted date is not pending in this active root turn',
+                                    type: 'inputText',
+                                }],
+                            success: false,
+                        },
+                    };
+                }
+                if (dynamicToolRequest.kind ===
+                    'automation-local-at-recovery-dismissal') {
+                    requiredAutomationLocalAtClarifications.delete(clarificationKey);
+                    return {
+                        rpcResult: {
+                            contentItems: [{
+                                    text: 'local-time reminder recovery dismissed; no automation was changed',
+                                    type: 'inputText',
+                                }],
+                            success: true,
+                        },
+                    };
+                }
+            }
+            if (dynamicToolRequest.kind === 'invalid-automation-arguments' &&
+                (dynamicToolRequest.safeFailureCode === 'local_at_gap' ||
+                    dynamicToolRequest.safeFailureCode === 'local_at_fold') &&
+                dynamicToolRequest.resolvedLocalDate &&
+                dynamicToolRequest.localAtTargetKey &&
+                dynamicToolRequest.localAtTargetLabel &&
+                !dynamicToolRequest.localAtRecovery) {
+                const requirement = {
+                    code: dynamicToolRequest.safeFailureCode,
+                    resolvedLocalDate: dynamicToolRequest.resolvedLocalDate,
+                    targetKey: dynamicToolRequest.localAtTargetKey,
+                    targetLabel: dynamicToolRequest.localAtTargetLabel,
+                };
+                requiredAutomationLocalAtClarifications.set(buildRequiredAutomationLocalAtClarificationKey(requirement), requirement);
+            }
             const result = await executeMurphDynamicToolRequest({
                 authorizeAcceptedMessageTarget: input.authorizeAcceptedMessageTarget ?? null,
                 assistantStyleSettingsOverlay,
@@ -2710,16 +3167,39 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
                 hostedToolContext,
                 materializeWorkspaceArtifacts: input.materializeWorkspaceArtifacts ?? null,
                 currentResponseMedia: responseMedia,
+                currentResponseCard: responseCard ?? responseCardTextFallback,
+                groupChallengeResponseCardAllowed: input.groupConversation === true &&
+                    input.dynamicTools.some((tool) => tool.namespace === 'murph' &&
+                        tool.name === 'attach_response_card'),
+                groupSharedReadTurnState,
+                privateDirectResponseCardAllowed: input.groupConversation === false,
+                telegramPresentationResponseCardAllowed: input.dynamicTools.some((tool) => tool.namespace === 'murph' &&
+                    (tool.name === 'attach_exercise_routine_card' ||
+                        tool.name === 'attach_telegram_rich_content')),
                 deliveryContextOrdinal: dynamicToolRequestDeliveryContextOrdinal,
                 nextUsageOrdinal: () => nextDynamicToolUsageOrdinal++,
+                onboardingFirstReadCompletionTransitionAvailable: input.onboardingFirstReadCompletionTransitionAvailable ?? false,
                 productFeedbackRecorder: input.productFeedbackRecorder ?? null,
                 progressDelivery: dynamicToolRequest.kind === 'send-progress-update'
                     ? dynamicToolProgressDelivery
-                    : null,
+                    : dynamicToolRequest.kind === 'group'
+                        ? resolveCodexAppServerProgressDelivery(input)
+                        : null,
                 publicFetchImpl: input.publicInternetFetch ?? null,
                 request: dynamicToolRequest,
                 requireHostedPrivateImageDelivery: input.requireHostedPrivateImageDelivery ?? false,
                 vaultRoot: input.vaultRoot ?? null,
+                voiceMemoPhaseTimingRecorder: (dynamicToolRequest.kind === 'generate-voice-memo' ||
+                    dynamicToolRequest.kind === 'generate-song') &&
+                    input.onTraceEvent
+                    ? (timing) => {
+                        emitCodexGeneratedAudioPhaseTimingTrace({
+                            codexThreadId,
+                            onTraceEvent: input.onTraceEvent,
+                            timing,
+                        });
+                    }
+                    : null,
                 voiceMemoRuntime: dynamicToolRequest.kind === 'generate-voice-memo' ||
                     dynamicToolRequest.kind === 'generate-song'
                     ? input.voiceMemoRuntime ?? null
@@ -2728,6 +3208,7 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
                     ? input.askGrokRuntime ?? null
                     : null,
                 askGrokTurnState,
+                generateSongTurnState,
             });
             return result;
         }).then(async (result) => {
@@ -2744,6 +3225,62 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
                 !requiredVaultFileApprovalUrls.includes(result.requiredVaultFileApprovalUrl)) {
                 requiredVaultFileApprovalUrls.push(result.requiredVaultFileApprovalUrl);
             }
+            if (result.finalActionPatch?.kind === 'none' &&
+                (result.finalActionPatch.owner === 'group-email'
+                    || result.finalActionPatch.owner === 'current-sender-ask')) {
+                if (result.externallyVisibleOutput) {
+                    markExternallyVisibleAssistantOutput(dynamicToolRequestDeliveryContextOrdinal);
+                }
+                applyTerminalExternalEffectNoReplyPatch(result.finalActionPatch, dynamicToolRequestDeliveryContextOrdinal);
+                // Interrupt while the app-server is still waiting on this dynamic
+                // tool request. Returning the tool result first lets Codex start a
+                // follow-up provider request before the interrupt is processed, and
+                // an interrupt racing that continuation can leave the turn open.
+                // TurnAborted resolves the pending server request structurally, so a
+                // terminal external effect must not also write a tool response.
+                dynamicToolRequestSettled = true;
+                await interruptLiveTurnForTerminalNoReply();
+                return;
+            }
+            if (result.externallyVisibleOutput) {
+                markExternallyVisibleAssistantOutput(dynamicToolRequestDeliveryContextOrdinal);
+            }
+            if (result.responseCardPatch) {
+                try {
+                    applyResponseCardPatch(result.responseCardPatch.card, dynamicToolRequestDeliveryContextOrdinal);
+                }
+                catch {
+                    void tryWriteRpcMessage({
+                        id: requestId,
+                        result: {
+                            success: false,
+                            contentItems: [{
+                                    type: 'inputText',
+                                    text: 'response card unavailable for this final response',
+                                }],
+                        },
+                    });
+                    return;
+                }
+            }
+            if (result.responseCardTextFallbackPatch) {
+                try {
+                    applyResponseCardTextFallbackPatch(result.responseCardTextFallbackPatch.card, dynamicToolRequestDeliveryContextOrdinal);
+                }
+                catch {
+                    void tryWriteRpcMessage({
+                        id: requestId,
+                        result: {
+                            success: false,
+                            contentItems: [{
+                                    type: 'inputText',
+                                    text: 'response card unavailable for this final response',
+                                }],
+                        },
+                    });
+                    return;
+                }
+            }
             if (result.responseMediaPatch) {
                 try {
                     applyResponseMediaPatch(result.responseMediaPatch, dynamicToolRequestDeliveryContextOrdinal);
@@ -2808,14 +3345,33 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
                 result.rpcResult.success) {
                 markExternallyVisibleAssistantOutput(dynamicToolDeliveryContextOrdinal ?? 0);
             }
-            void tryWriteRpcMessage({
+            if (dynamicToolRequest.kind === 'automation' &&
+                result.rpcResult.success &&
+                dynamicToolRequest.localAtRecovery) {
+                const recoveryKey = buildRequiredAutomationLocalAtClarificationKey({
+                    resolvedLocalDate: dynamicToolRequest.localAtRecovery.resolvedLocalDate,
+                    targetKey: dynamicToolRequest.localAtRecovery.recoveryKey,
+                });
+                if (requiredAutomationLocalAtClarifications.has(recoveryKey)) {
+                    requiredAutomationLocalAtClarifications.delete(recoveryKey);
+                }
+            }
+            const writeFailure = tryWriteRpcMessage({
                 id: requestId,
                 result: result.rpcResult,
             });
+            if (writeFailure) {
+                return;
+            }
+            dynamicToolRequestSettled = true;
         }).catch((error) => {
             if (dynamicToolRequest.kind === 'send-progress-update') {
                 releaseDynamicProgressPending?.();
             }
+            if (dynamicToolRequestSettled) {
+                rejectOnce(error);
+                return;
+            }
             pushRuntimeIssueInput(createDynamicToolRuntimeIssueInput({
                 request: dynamicToolRequest,
                 reason: 'execution_failed',
@@ -2853,6 +3409,10 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
         const providerRequestStartedAtMs = codexProviderRequestStartedAtMs;
         const isTurnStartedNotification = isCodexTurnStartedMethod(method);
         const isTurnCompletedNotification = isCodexTurnCompletedMethod(method);
+        if (isTurnStartedNotification) {
+            currentTurnStartedNotificationObserved =
+                turnId !== null && extractCodexTurnIdFromMessage(message) === turnId;
+        }
         const shouldCaptureTurnStartedNotification = providerRequestStartedAtMs !== null &&
             isTurnStartedNotification &&
             codexTimingTurnStartedNotificationElapsedMs === null;
@@ -2876,7 +3436,8 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
         lastEventError = extractCodexErrorMessage(message) ?? lastEventError;
         lastEventErrorInfo = extractCodexErrorInfo(message) ?? lastEventErrorInfo;
         const normalizedEvent = normalizeCodexEvent(message);
-        const runtimeIssueInput = buildRuntimeIssueInputForFailedCodexAction({
+        const runtimeIssueInput = actionRuntimeIssueTracker.recordEvent({
+            activeTurnId: turnId,
             normalizedEvent,
             rawEvent: message,
         });
@@ -2937,7 +3498,7 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             }
         }
         if (normalizedEvent.kind !== 'status_item' ||
-            normalizedEvent.itemType !== 'context.compaction') {
+            normalizedEvent.itemType !== 'contextCompaction') {
             input.onTraceEvent?.({
                 codexThreadId,
                 rawEvent: message,
@@ -2974,6 +3535,8 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
                     deliveryContextOrdinal: completedResponseDeliveryContextOrdinal,
                     response: completedFinalAgentMessage,
                     media: [...responseMedia],
+                    card: responseCard,
+                    cardTextFallback: responseCardTextFallback,
                     ...(completedResponseTargetInputId
                         ? { targetInputId: completedResponseTargetInputId }
                         : {}),
@@ -2983,6 +3546,8 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
                 assistantStreamOrder.length = 0;
                 responseMedia = [];
             }
+            responseCard = null;
+            responseCardTextFallback = null;
             completedUserMessageOrdinal += 1;
         }
         const progressEvent = extractCodexProgressEventFromNormalized(normalizedEvent);
@@ -3008,6 +3573,12 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             return;
         }
         const status = extractCodexTurnStatus(message);
+        if (status === 'interrupted' &&
+            terminalNoReplyInterruptRequested) {
+            turnTerminal = true;
+            completeTurn?.();
+            return;
+        }
         if (isFailedCodexTurnStatus(status)) {
             turnTerminal = true;
             failTurn?.(buildCodexTurnFailedError({
@@ -3034,30 +3605,61 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             });
             return;
         }
-        if (!isAssistantCodexTokenUsageEventType(readCodexEventMethod(message))) {
+        const eventMethod = readCodexEventMethod(message);
+        const messageTurnId = extractCodexTurnIdFromMessage(message);
+        if (isCodexTurnStartedMethod(eventMethod)) {
+            if (!messageTurnId) {
+                return;
+            }
+            const usageKey = createCodexSubagentTurnUsageKey({
+                threadId,
+                turnId: messageTurnId,
+            });
+            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(),
+                threadId,
+                turnId: messageTurnId,
+            });
             return;
         }
-        const sample = subagentTokenUsageByThread.get(threadId);
-        if (sample) {
-            sample.lastEvent = message;
+        if (!isAssistantCodexTokenUsageEventType(eventMethod)
+            || !messageTurnId) {
             return;
         }
-        if (subagentTokenUsageByThread.size >= MAX_CODEX_SUBAGENT_USAGE_THREADS) {
-            // Evidenced subagent threads win buffer slots: evict an unattributed
-            // sample (e.g. a stale flush from a previous warm-process thread, which
-            // is never billable) before dropping a billable child's usage.
-            const evictableThreadId = collabReceiverThreadIds.has(threadId)
-                ? [...subagentTokenUsageByThread.keys()].find((bufferedThreadId) => !collabReceiverThreadIds.has(bufferedThreadId))
-                : undefined;
-            if (evictableThreadId === undefined) {
-                return;
-            }
-            subagentTokenUsageByThread.delete(evictableThreadId);
-        }
-        subagentTokenUsageByThread.set(threadId, {
-            firstEvent: message,
-            lastEvent: message,
+        const usageKey = createCodexSubagentTurnUsageKey({
+            threadId,
+            turnId: messageTurnId,
         });
+        const sample = subagentTokenUsageByTurn.get(usageKey);
+        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.
+            return;
+        }
+        sample.firstEvent ??= message;
+        sample.lastEvent = message;
     };
     const handleStaleParentTurnMessage = (message) => {
         const requestId = readCodexRpcServerRequestId(message);
@@ -3170,10 +3772,17 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
                 rejectPreStartParentTurnRequest(requestId);
                 return;
             }
-            handleAcceptedServerRequest(message, requestId);
+            trackDynamicToolRequest(handleAcceptedServerRequest(message, requestId));
             return;
         }
-        if (isReusedWarmProcess && messageTurnId === null) {
+        if (messageTurnId === null &&
+            method === 'model/rerouted' &&
+            !currentTurnStartedNotificationObserved) {
+            return;
+        }
+        if (isReusedWarmProcess &&
+            messageTurnId === null &&
+            method !== 'model/rerouted') {
             return;
         }
         handleAcceptedEvent(message, method);
@@ -3216,15 +3825,31 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
     };
     const steerLiveTurn = async (steerInput) => {
         const liveTurn = requireLiveTurnIds();
-        const steerImagePaths = await materializeCodexImagePaths({
-            images: steerInput.images,
+        const preparedSteerImages = await materializeCodexImages({
+            images: normalizeCodexAppServerImageDetails({
+                images: steerInput.images,
+                model: input.model,
+                modelProvider: input.modelProvider,
+                turnKind: 'steer',
+            }),
             tempRoot: input.tempRoot,
         });
-        await withCodexRpcTimeout(sendRequest('turn/steer', buildCodexTurnSteerParams({
-            ...liveTurn,
-            imagePaths: steerImagePaths,
-            prompt: steerInput.prompt,
-        })), CODEX_RPC_STEER_TIMEOUT_MS, 'turn/steer');
+        const deliveryContextOrdinal = automationRelativeDateReferenceWindows.length;
+        automationRelativeDateReferenceWindows.push(mergeAutomationRelativeDateReferenceWindows(automationRelativeDateReferenceWindows.at(-1) ?? null, steerInput.relativeDateReferenceWindow ?? null));
+        try {
+            await withCodexRpcTimeout(sendRequest('turn/steer', buildCodexTurnSteerParams({
+                ...liveTurn,
+                images: preparedSteerImages,
+                prompt: steerInput.prompt,
+            })), CODEX_RPC_STEER_TIMEOUT_MS, 'turn/steer');
+        }
+        catch (error) {
+            if (automationRelativeDateReferenceWindows.length ===
+                deliveryContextOrdinal + 1) {
+                automationRelativeDateReferenceWindows.pop();
+            }
+            throw error;
+        }
     };
     const interruptLiveTurn = async () => {
         const liveTurn = requireLiveTurnIds();
@@ -3232,6 +3857,17 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
         scheduleInterruptCleanupTimeout();
         await withCodexRpcTimeout(sendRequest('turn/interrupt', buildCodexTurnInterruptParams(liveTurn)), CODEX_RPC_STEER_TIMEOUT_MS, 'turn/interrupt');
     };
+    const interruptLiveTurnForTerminalNoReply = async () => {
+        if (!codexThreadId || !turnId || turnTerminal) {
+            throw buildLiveTurnInactiveError();
+        }
+        terminalNoReplyInterruptRequested = true;
+        scheduleInterruptCleanupTimeout();
+        await withCodexRpcTimeout(sendRequest('turn/interrupt', buildCodexTurnInterruptParams({
+            threadId: codexThreadId,
+            turnId,
+        })), CODEX_RPC_STEER_TIMEOUT_MS, 'turn/interrupt');
+    };
     const registerLiveTurn = () => {
         if (computerToolsLockedAfterUserPause ||
             liveTurnOpen ||
@@ -3301,7 +3937,11 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             emitAppServerTimingTrace('spawn-ready');
             await codexProcess.initialize();
             lifecycleStage = 'initialized';
-            emitAppServerTimingTrace('initialized');
+            emitAppServerTimingTrace(codexProcess.wasPreinitialized ? 'preinitialized' : 'initialized');
+        }
+        else if (!codexProcess.hasCompletedTurn) {
+            lifecycleStage = 'initialized';
+            emitAppServerTimingTrace('preinitialized');
         }
         else {
             lifecycleStage = 'initialized';
@@ -3347,26 +3987,28 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
         codexProcess.noteBoundThreadServiceTier(input.serviceTier ?? null);
         const turnStartRequest = sendRequest('turn/start', buildCodexTurnStartParams({
             input,
-            imagePaths: input.imagePaths,
+            images: input.preparedImages,
             codexThreadId,
         }));
+        const providerStartedAtMonotonicMs = readAssistantProviderStartMonotonicTickMs();
         // The child can begin executing (including side-effecting commands) as
         // soon as the turn/start request is written, so the provider-start
         // barrier arms here rather than at the acknowledgement. A death between
         // write and response must never be classified as pre-provider work.
-        notifyProviderRequestStarted();
+        notifyProviderRequestStarted(providerStartedAtMonotonicMs);
         const turnResult = await withCodexRpcTimeout(turnStartRequest, CODEX_RPC_DEFAULT_TIMEOUT_MS, 'turn/start');
         acceptTurnStartResultTurnId(extractCodexTurnIdFromResult(turnResult));
         lifecycleStage = 'turn_started';
         emitAppServerTimingTrace('turn-started');
-        registerLiveTurn();
         lifecycleStage = 'turn_running';
         await turnCompleted;
         clearInterruptCleanupTimer();
+        await drainPendingDynamicToolRequests();
         await drainPendingDynamicToolExecutions();
         await drainPendingProgressDeliveries();
         emitActionDiagnosticsTrace();
         lifecycleStage = 'turn_completed';
+        codexProcess.noteTurnCompleted();
         emitAppServerTimingTrace('turn-completed');
         closeLiveTurn();
         if (stdinFailure) {
@@ -3412,6 +4054,7 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             ? (buildRecordedTerminationError(lastEventError) ?? error)
             : error;
         emitActionDiagnosticsTrace();
+        await drainPendingDynamicToolRequests();
         dynamicToolAbortController.abort();
         await drainPendingDynamicToolExecutions();
         await drainPendingProgressDeliveries();
@@ -3454,7 +4097,9 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
         (latestFinalActionPatch?.kind === 'none' ||
             (!suppressTrailingSteerCandidateForEarlierNoReply &&
                 (normalizeNullableString(extractedFinalMessage) !== null ||
-                    responseMedia.length > 0)));
+                    responseMedia.length > 0 ||
+                    responseCard !== null ||
+                    responseCardTextFallback !== null)));
     if (shouldPromoteTrailingSteerCandidate) {
         promoteTrailingSteerCandidate();
         finalTrailingSteerCandidate = null;
@@ -3465,12 +4110,29 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
         : suppressTrailingSteerCandidateForEarlierNoReply
             ? responseMedia
             : finalTrailingSteerCandidate?.media ?? responseMedia;
+    const finalResponseCard = latestFinalActionPatch?.kind === 'none'
+        ? responseCard
+        : suppressTrailingSteerCandidateForEarlierNoReply
+            ? responseCard
+            : finalTrailingSteerCandidate?.card ?? responseCard;
+    if (finalResponseCard !== null && finalResponseMedia.length > 0) {
+        throw new VaultCliError('ASSISTANT_RESPONSE_CARD_MEDIA_CONFLICT', 'A response card cannot be combined with response media.');
+    }
     const finalDeliveryContextOrdinal = latestFinalActionPatch?.kind === 'none'
         ? latestDeliveryContextOrdinal
         : suppressTrailingSteerCandidateForEarlierNoReply
             ? latestDeliveryContextOrdinal
             : finalTrailingSteerCandidate?.deliveryContextOrdinal ??
                 latestDeliveryContextOrdinal;
+    const finalResponseCardTextFallback = latestFinalActionPatch?.kind === 'none'
+        ? responseCardTextFallback
+        : suppressTrailingSteerCandidateForEarlierNoReply
+            ? responseCardTextFallback
+            : finalTrailingSteerCandidate?.cardTextFallback
+                ?? responseCardTextFallback;
+    if (finalResponseCardTextFallback !== null && finalResponseMedia.length > 0) {
+        throw new VaultCliError('ASSISTANT_RESPONSE_CARD_MEDIA_CONFLICT', 'Response card text recovery cannot be combined with response media.');
+    }
     const finalActionPatch = resolveFinalActionPatch(finalDeliveryContextOrdinal);
     const requiredUserVisibleOutput = hasRequiredUserVisibleOutput();
     const noReplySelected = finalActionPatch?.kind === 'none' && !requiredUserVisibleOutput;
@@ -3480,7 +4142,24 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
     const modelFinalMessage = noReplySelected || suppressTrailingSteerCandidateForEarlierNoReply
         ? ''
         : selectedFinalMessage;
-    const finalMessage = appendRequiredVaultFileApprovalUrls(modelFinalMessage, requiredVaultFileApprovalUrls);
+    const semanticFinalMessage = finalResponseCard
+        ? renderAssistantResponseCardText(finalResponseCard)
+        : finalResponseCardTextFallback
+            ? renderAssistantWorkoutResponseCardText(finalResponseCardTextFallback)
+            : modelFinalMessage;
+    const requiredAutomationLocalAtClarificationsInOrder = [...requiredAutomationLocalAtClarifications.values()];
+    const deliveredFinalResponseCard = requiredAutomationLocalAtClarificationsInOrder.length === 0
+        ? finalResponseCard
+        : null;
+    const finalMessage = appendRequiredVaultFileApprovalUrls(appendRequiredAutomationLocalAtClarification(semanticFinalMessage, requiredAutomationLocalAtClarificationsInOrder), requiredVaultFileApprovalUrls);
+    const transcriptMessage = appendRequiredAutomationLocalAtClarification(finalResponseCard
+        ? requiredAutomationLocalAtClarificationsInOrder.length === 0
+            ? renderAssistantResponseCardTranscriptText(finalResponseCard)
+            : renderAssistantResponseCardText(finalResponseCard)
+        : finalResponseCardTextFallback
+            ? renderAssistantWorkoutResponseCardTranscriptText(finalResponseCardTextFallback)
+            : normalizeNullableString(modelFinalMessage) ??
+                (finalResponseMedia.length > 0 ? '' : null), requiredAutomationLocalAtClarificationsInOrder);
     if (noReplySelected &&
         normalizeNullableString(extractedFinalMessage) !== null) {
         emitCodexSuppressedFinalMessageTrace({
@@ -3493,14 +4172,16 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
     const filteredPrecedingAgentMessageSegments = precedingAgentMessageSegments
         .filter((segment) => !shouldSuppressDeliveryContext(segment.deliveryContextOrdinal));
     const finalHasDeliverableOutput = normalizeNullableString(finalMessage) !== null ||
-        (!noReplySelected && finalResponseMedia.length > 0);
+        (!noReplySelected && (finalResponseMedia.length > 0 ||
+            deliveredFinalResponseCard !== null ||
+            finalResponseCardTextFallback !== null));
     return {
         acceptedNoReplyDeliveryContextOrdinals: acceptedNoReplyDeliveryContextOrdinals,
         finalAction,
         finalActionExplicit: finalActionPatch?.kind === 'none' && !requiredUserVisibleOutput,
         finalMessage,
-        transcriptMessage: normalizeNullableString(modelFinalMessage) ??
-            (finalResponseMedia.length > 0 ? '' : null),
+        providerAuthoredFinalMessage: modelFinalMessage,
+        transcriptMessage,
         reactions: reactionPatches.map((entry) => ({
             deliveryContextOrdinal: entry.deliveryContextOrdinal,
             reaction: entry.patch.reaction,
@@ -3509,6 +4190,9 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
         precedingAgentMessageSegments: filteredPrecedingAgentMessageSegments.map((segment) => ({
             deliveryContextOrdinal: segment.deliveryContextOrdinal,
             response: segment.response,
+            ...(segment.transcriptResponse === undefined
+                ? {}
+                : { transcriptResponse: segment.transcriptResponse }),
             media: [...segment.media],
             ...(segment.targetInputId
                 ? { targetInputId: segment.targetInputId }
@@ -3518,6 +4202,7 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
         targetInputId: resolveReplyTargetPatch(finalDeliveryContextOrdinal)?.targetInputId ?? null,
         additionalUsages: [...additionalUsages, ...buildSubagentUsageDrafts()],
         responseMedia: finalHasDeliverableOutput ? [...finalResponseMedia] : [],
+        responseCard: finalHasDeliverableOutput ? deliveredFinalResponseCard : null,
         jsonEvents,
         providerActionCount,
         runtimeIssueInputs,
@@ -3529,6 +4214,23 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
         turnId,
     };
 }
+function mergeAutomationRelativeDateReferenceWindows(preceding, current) {
+    if (current === null) {
+        return null;
+    }
+    if (preceding === null) {
+        return { ...current };
+    }
+    const earliestAtMs = Math.min(Date.parse(preceding.earliestAt), Date.parse(current.earliestAt));
+    const latestAtMs = Math.max(Date.parse(preceding.latestAt), Date.parse(current.latestAt));
+    if (!Number.isFinite(earliestAtMs) || !Number.isFinite(latestAtMs)) {
+        return null;
+    }
+    return {
+        earliestAt: new Date(earliestAtMs).toISOString(),
+        latestAt: new Date(latestAtMs).toISOString(),
+    };
+}
 function assertCodexThreadStartPermissionAttestation(input) {
     const result = asCodexRecord(input.threadResult);
     const activePermissionProfile = asCodexRecord(result?.activePermissionProfile);
@@ -3553,7 +4255,8 @@ function assertCodexThreadStartPermissionAttestation(input) {
     if (!actualCwd || path.resolve(actualCwd) !== input.input.workingDirectory) {
         mismatchedFields.push('cwd');
     }
-    if (instructionSources === null || instructionSources.length !== 0) {
+    if (input.input.processLifetime === 'one-shot' &&
+        (instructionSources === null || instructionSources.length !== 0)) {
         mismatchedFields.push('instructionSources');
     }
     if (asCodexString(result?.approvalPolicy) !==
@@ -3563,7 +4266,7 @@ function assertCodexThreadStartPermissionAttestation(input) {
     if (mismatchedFields.length === 0) {
         return;
     }
-    throw new VaultCliError('ASSISTANT_CODEX_APP_SERVER_PERMISSION_ATTESTATION_FAILED', 'Codex app-server did not attest the requested read-only execution context.', {
+    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,
     });
@@ -3588,6 +4291,36 @@ function emitCodexSuppressedFinalMessageTrace(input) {
         // Diagnostic-only.
     }
 }
+function emitCodexGeneratedAudioPhaseTimingTrace(input) {
+    if (!input.onTraceEvent) {
+        return;
+    }
+    try {
+        input.onTraceEvent({
+            codexThreadId: input.codexThreadId,
+            rawEvent: {
+                schema: CODEX_GENERATED_AUDIO_PHASE_TIMING_TRACE_SCHEMA,
+                type: CODEX_GENERATED_AUDIO_PHASE_TIMING_TRACE_TYPE,
+                generatedAudioDeliveryMode: input.timing.deliveryMode,
+                ...(input.timing.generationDurationMs === undefined
+                    ? {}
+                    : {
+                        generatedAudioGenerationDurationMs: input.timing.generationDurationMs,
+                    }),
+                generatedAudioKind: input.timing.mediaKind,
+                generatedAudioOutcome: input.timing.outcome,
+                generatedAudioTerminalPhase: input.timing.terminalPhase,
+                ...(input.timing.uploadDurationMs === undefined
+                    ? {}
+                    : { generatedAudioUploadDurationMs: input.timing.uploadDurationMs }),
+            },
+            updates: [],
+        });
+    }
+    catch {
+        // Phase timing is diagnostic-only and must not block assistant turns.
+    }
+}
 function notifyCodexAppServerProviderRequestStartedBestEffort(input) {
     if (!input.hook) {
         return;
@@ -3611,31 +4344,51 @@ function isInvalidDynamicToolRequest(request) {
         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');
 }
 function isSerializedDynamicToolRequest(request) {
     return request.kind === 'automation' ||
+        request.kind === 'automation-local-at-recovery-dismissal' ||
+        request.kind === 'invalid-automation-arguments' ||
         request.kind === 'device' ||
         request.kind === 'generate-image' ||
         request.kind === 'generate-voice-memo' ||
         request.kind === 'generate-song' ||
+        request.kind === 'attach-group-challenge-response-card' ||
+        request.kind === 'attach-response-card' ||
+        request.kind === 'response-card-envelope-too-large' ||
         request.kind === 'attach-response-media' ||
         request.kind === 'send-vault-file' ||
+        request.kind === 'pending-vault-files-list' ||
+        request.kind === 'pending-vault-files-cancel' ||
         request.kind === 'assistant-configuration' ||
         request.kind === 'assistant-style' ||
         request.kind === 'personalization' ||
         request.kind === 'subscription' ||
+        (request.kind === 'group' &&
+            request.request.action === 'ask_current_sender' &&
+            request.request.mode !== 'new') ||
         request.kind === 'react-to-message' ||
         request.kind === 'select-reply-target' ||
-        isComputerDynamicToolRequest(request);
+        request.kind === 'computer-open' ||
+        request.kind === 'computer-act' ||
+        request.kind === 'computer-os-control' ||
+        request.kind === 'computer-pause-for-user' ||
+        request.kind === 'computer-finish-run' ||
+        request.kind === 'invalid-computer-arguments';
 }
-function isResponseMediaDynamicToolRequest(request) {
-    return request.kind === 'attach-response-media' ||
+function isResponseAttachmentDynamicToolRequest(request) {
+    return request.kind === 'attach-group-challenge-response-card' ||
+        request.kind === 'attach-response-card' ||
+        request.kind === 'response-card-envelope-too-large' ||
+        request.kind === 'attach-response-media' ||
         request.kind === 'generate-image' ||
         request.kind === 'generate-song' ||
         request.kind === 'generate-voice-memo' ||
@@ -3643,9 +4396,13 @@ function isResponseMediaDynamicToolRequest(request) {
 }
 function isInvocationScopedRootToolRequest(request) {
     return request.kind === 'automation' ||
+        request.kind === 'automation-local-at-recovery-dismissal' ||
         request.kind === 'invalid-automation-arguments' ||
         request.kind === 'device' ||
         request.kind === 'invalid-device-arguments' ||
+        request.kind === 'pending-vault-files-list' ||
+        request.kind === 'pending-vault-files-cancel' ||
+        request.kind === 'invalid-pending-vault-files-arguments' ||
         request.kind === 'react-to-message' ||
         request.kind === 'select-reply-target' ||
         request.kind === 'invalid-reaction-arguments' ||
@@ -3726,6 +4483,7 @@ function resolveCodexRolloutRelativePath(input) {
 function assertCodexResumeContextMatches(input) {
     const result = asCodexRecord(input.threadResult);
     const actualCwd = normalizeNullableString(asCodexString(result?.cwd));
+    const expectedPermissions = normalizeNullableString(input.input.permissions);
     const checks = [
         [
             'threadId',
@@ -3745,13 +4503,30 @@ function assertCodexResumeContextMatches(input) {
         ],
         [
             'sandbox',
-            mapCodexAppServerSandboxMode(input.input.sandbox) ?? null,
+            expectedPermissions
+                ? null
+                : mapCodexAppServerSandboxMode(input.input.sandbox) ?? null,
             readCodexResumeSandboxMode(result?.sandbox),
         ],
     ];
     const mismatchedFields = checks
         .filter(([, expected, actual]) => expected !== null && actual !== expected)
         .map(([field]) => field);
+    if (expectedPermissions) {
+        const activePermissionProfile = asCodexRecord(result?.activePermissionProfile);
+        const actualRoots = asCodexStringArray(result?.runtimeWorkspaceRoots);
+        const expectedRoots = input.input.runtimeWorkspaceRoots ?? [];
+        if (normalizeNullableString(asCodexString(activePermissionProfile?.id)) !==
+            expectedPermissions ||
+            normalizeNullableString(asCodexString(activePermissionProfile?.extends)) !== null) {
+            mismatchedFields.push('activePermissionProfile');
+        }
+        if (!actualRoots ||
+            actualRoots.length !== expectedRoots.length ||
+            actualRoots.some((root, index) => path.resolve(root) !== path.resolve(expectedRoots[index] ?? ''))) {
+            mismatchedFields.push('runtimeWorkspaceRoots');
+        }
+    }
     if (mismatchedFields.length === 0) {
         return;
     }
@@ -3812,14 +4587,13 @@ function normalizeCodexRolloutRelativePath(value, codexThreadId) {
     return value;
 }
 function extractCodexProviderActionKey(normalizedEvent, rawEvent) {
+    if (isCodexProductFeedbackDynamicToolEvent(rawEvent)) {
+        return null;
+    }
     if (normalizedEvent.kind === 'status_item') {
-        if (normalizedEvent.itemType !== 'command.execution' &&
-            normalizedEvent.itemType !== 'dynamic.tool.call' &&
-            normalizedEvent.itemType !== 'file.change') {
-            return null;
-        }
-        if (normalizedEvent.itemType === 'dynamic.tool.call' &&
-            isCodexProductFeedbackDynamicToolEvent(rawEvent)) {
+        if (normalizedEvent.itemType !== 'commandExecution' &&
+            normalizedEvent.itemType !== 'dynamicToolCall' &&
+            normalizedEvent.itemType !== 'fileChange') {
             return null;
         }
         return (normalizedEvent.itemId ??
@@ -3833,17 +4607,10 @@ function extractCodexProviderActionKey(normalizedEvent, rawEvent) {
         providerActionFallbackKeyFromNormalized(normalizedEvent));
 }
 function isCodexProductFeedbackDynamicToolEvent(event) {
-    const params = readCodexRecordField(event, 'params');
-    const data = readCodexRecordField(event, 'data');
-    const item = readCodexRecordField(event, 'item') ??
-        readCodexRecordField(params, 'item') ??
-        readCodexRecordField(data, 'item');
-    const itemType = readCodexStringField(item, 'type')
-        ?.replaceAll(/[._-]/gu, '')
-        .toLowerCase();
-    return (itemType === 'dynamictoolcall' &&
-        readCodexStringField(item, 'namespace') === 'murph' &&
-        readCodexStringField(item, 'tool') === 'submit_product_feedback');
+    const item = readCodexRecord(readCodexRecord(event.params)?.item);
+    return (item?.type === 'dynamicToolCall' &&
+        item.namespace === 'murph' &&
+        item.tool === 'submit_product_feedback');
 }
 function providerActionFallbackKeyFromNormalized(event) {
     switch (event.kind) {