@murphai/murph 1.3.0 → 1.3.2

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

@@ -3,23 +3,29 @@ 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 { buildCodexTurnInterruptParams, buildCodexThreadMetadataResumeParams, buildCodexThreadResumeParams, buildCodexThreadStartParams, buildCodexTurnSteerParams, buildCodexTurnStartParams, mapCodexAppServerApprovalPolicy, mapCodexAppServerSandboxMode, resolveSupportedCodexAppServerApprovalPolicy, } from './assistant-codex/app-server-requests.js';
+import { createCodexActionDiagnosticsReducer, createCodexActionRuntimeIssueTracker, } from './assistant-codex/action-diagnostics.js';
+import { createCodexWorkoutDeliveryContextTracker, } from './assistant-codex/workout-delivery-context.js';
+import { MURPH_ASSISTANT_STYLE_TOOL, MURPH_GROUP_ROOM_MODEL_TOOL, MURPH_MEMBER_MEMORY_TOOL, } from './assistant-codex/dynamic-tool-catalog.js';
 import { createAskGrokTurnState, } from './assistant-codex/ask-grok-tool.js';
+import { createAnalyzeVideoTurnState, } from './assistant-codex/analyze-video-tool.js';
 import { attachCodexAppServerProcessExitCleanup, attachCodexAbortListener, consumeCompleteLines, denyUnsupportedCodexServerRequest, rejectCodexServerRequest, readCodexRpcResponseId, readCodexRpcServerRequestId, rejectPendingCodexRpcRequests, resolvePendingCodexRpcRequest, signalCodexAppServerChild, stopCodexAppServerChild, stripUndefinedRpcParams, tryParseJsonLine, waitForCodexSpawn, withCodexRpcTimeout, writeCodexRpcMessage, } from './assistant-codex/app-server-rpc.js';
+import { readCodexNonEmptyString, readCodexRecord, readCodexThreadTokenUsage, } from './assistant-codex/app-server-protocol.js';
 import { resolveCodexChildEnv, withHostedCodexModelCatalogConfigOverride, } from './assistant-codex/config.js';
 import { buildCodexProcessExitError, buildCodexStdinFailureFallback, buildCodexTurnFailedError, extractCodexThreadIdFromMessage, extractCodexThreadIdFromResult, extractCodexThreadPathFromResult, extractCodexTurnErrorMessage, extractCodexTurnIdFromMessage, extractCodexTurnIdFromResult, extractCodexTurnStatus, isFailedCodexTurnStatus, readNodeErrorCode, } from './assistant-codex/failures.js';
-import { extractCodexSubagentUsageDrafts, isAssistantCodexTokenUsageEventType, readCodexCollabReceiverThreadIds, } from './assistant/providers/helpers.js';
-import { materializeCodexImagePaths, } from './assistant-codex/images.js';
-import { normalizeAssistantResponseMediaList, } from './assistant/response-media.js';
+import { buildCodexSubagentUsageDraft, extractCodexSubagentUsageDrafts, isAssistantCodexTokenUsageEventType, } from './assistant/providers/helpers.js';
+import { materializeCodexImages, normalizeCodexAppServerImageDetails, } from './assistant-codex/images.js';
+import { ASSISTANT_AUTHORED_RESPONSE_MEDIA_MAX_ITEMS, normalizeAssistantResponseMediaList, } from './assistant/response-media.js';
+import { completeAssistantProviderStartCriticalPath, readAssistantProviderStartMonotonicTickMs, stampAssistantProviderStartCriticalPath, } from './assistant/provider-start-critical-path.js';
 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 +35,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,10 +52,9 @@ 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.
-const MAX_CODEX_SUBAGENT_USAGE_THREADS = 32;
 function prepareCodexRpcParams(method, params) {
     const stripped = stripUndefinedRpcParams(params);
     if (method === 'turn/start' &&
@@ -53,64 +64,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 +183,64 @@ 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,
+        analyzeVideoRuntime: input.analyzeVideoRuntime ?? 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;
@@ -351,13 +424,16 @@ class CodexAppServerProcess {
     // reply.
     detachedChildThreadIds = new Set();
     detachedCompletedChildThreadIds = new Set();
+    detachedChildMessageHandlers = new Map();
     detachedChildViolation = null;
     detachedRootThreadIds = new Set();
+    pendingDetachedUsageReports = new Set();
     stopCompleted = false;
     state = 'idle';
     stderrBuffer = '';
     startupStderr = '';
     startupFailure = null;
+    spawnReadyPromise = null;
     stdinFailure = null;
     stdoutBuffer = '';
     stopPromise = null;
@@ -408,6 +484,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 +508,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 +577,10 @@ class CodexAppServerProcess {
         });
     }
     async waitForSpawn() {
+        this.spawnReadyPromise ??= this.runWaitForSpawn();
+        await this.spawnReadyPromise;
+    }
+    async runWaitForSpawn() {
         this.throwStartupFailure();
         try {
             await waitForCodexSpawn(this.child);
@@ -482,9 +594,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,
@@ -507,9 +628,18 @@ class CodexAppServerProcess {
         rejectPendingCodexRpcRequests(this.pendingRequests, error);
     }
     sendRequest(method, params) {
+        return this.beginRequest(method, params).promise;
+    }
+    sendRequestWithTimeout(input) {
+        const request = this.beginRequest(input.method, input.params);
+        return withCodexRpcTimeout(request.promise, input.timeoutMs, input.timeoutLabel, () => {
+            this.pendingRequests.delete(request.id);
+        });
+    }
+    beginRequest(method, params) {
         const id = this.nextRequestId;
         this.nextRequestId += 1;
-        return new Promise((resolve, reject) => {
+        const promise = new Promise((resolve, reject) => {
             this.pendingRequests.set(id, {
                 method,
                 reject,
@@ -525,6 +655,7 @@ class CodexAppServerProcess {
                 reject(failure);
             }
         });
+        return { id, promise };
     }
     sendNotification(method, params) {
         void this.writeRpcMessage({
@@ -549,6 +680,7 @@ class CodexAppServerProcess {
             this.assertBackgroundWorkProcessAvailable();
             await this.waitForDetachedChildren(signal);
             this.assertDetachedChildrenQuiescent();
+            await this.waitForDetachedUsageReports(signal);
             await this.assertNoBackgroundTerminals(signal);
             throwIfCodexBackgroundWorkWaitAborted(signal);
             this.assertBackgroundWorkProcessAvailable();
@@ -569,7 +701,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 });
@@ -605,6 +738,18 @@ class CodexAppServerProcess {
             throw new VaultCliError('ASSISTANT_CODEX_BACKGROUND_WORK_FAILED', 'Detached Codex work was still active at the workspace boundary.', { retryable: true });
         }
     }
+    trackDetachedUsageReport(report) {
+        this.pendingDetachedUsageReports.add(report);
+        void report.finally(() => {
+            this.pendingDetachedUsageReports.delete(report);
+        });
+    }
+    async waitForDetachedUsageReports(signal) {
+        while (this.pendingDetachedUsageReports.size > 0) {
+            throwIfCodexBackgroundWorkWaitAborted(signal);
+            await Promise.all([...this.pendingDetachedUsageReports]);
+        }
+    }
     async assertNoBackgroundTerminals(signal) {
         const threadIds = new Set([
             ...this.detachedRootThreadIds,
@@ -624,6 +769,7 @@ class CodexAppServerProcess {
     clearDetachedChildBoundary() {
         this.detachedChildThreadIds.clear();
         this.detachedCompletedChildThreadIds.clear();
+        this.detachedChildMessageHandlers.clear();
         this.detachedChildViolation = null;
         this.detachedRootThreadIds.clear();
     }
@@ -643,6 +789,9 @@ class CodexAppServerProcess {
                 }
                 else {
                     this.detachedChildThreadIds.add(activity.agentThreadId);
+                    if (this.activeTurn?.onSubagentMessage) {
+                        this.detachedChildMessageHandlers.set(activity.agentThreadId, this.activeTurn.onSubagentMessage);
+                    }
                 }
             }
             else {
@@ -690,6 +839,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 +875,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) {
@@ -872,11 +1022,6 @@ class CodexAppServerProcess {
     noteBoundThreadModel(model) {
         this.boundThreadModel = normalizeNullableString(model);
     }
-    // Exposed so a freshly bound turn can route foreign-thread events before
-    // its own thread/start response has produced the new thread id.
-    get lastBoundThreadId() {
-        return this.boundThreadId;
-    }
     handleIdleServerMessage(message) {
         const responseId = readCodexRpcResponseId(message);
         if (responseId !== null) {
@@ -900,11 +1045,41 @@ class CodexAppServerProcess {
             writeRpcMessage: (payload) => void this.writeRpcMessage(payload),
         });
     }
+    routeSubagentMessage(message) {
+        if (readCodexRpcResponseId(message) !== null) {
+            return false;
+        }
+        const threadId = extractCodexThreadIdFromMessage(message);
+        if (!threadId || this.detachedRootThreadIds.has(threadId)) {
+            return false;
+        }
+        let handler = this.detachedChildMessageHandlers.get(threadId);
+        const activeHandler = this.activeTurn?.onSubagentMessage;
+        if (!handler && activeHandler) {
+            // The app-server process is exclusively owned by Assistant Engine. A
+            // foreign thread notification on an active root is therefore enough to
+            // correlate that child with the current turn; parent item shape is not a
+            // billing authorization boundary.
+            handler = activeHandler;
+            this.detachedChildMessageHandlers.set(threadId, handler);
+        }
+        if (!handler) {
+            return false;
+        }
+        if (isCodexTurnStartedMethod(readCodexEventMethod(message))) {
+            this.detachedChildThreadIds.add(threadId);
+        }
+        handler(message);
+        return true;
+    }
     handleStdoutLine(line) {
         const parsed = tryParseJsonLine(line);
         if (parsed.ok) {
             this.observeDetachedChildLifecycle(parsed.value);
             this.observeThreadTokenUsage(parsed.value);
+            if (this.routeSubagentMessage(parsed.value)) {
+                return;
+            }
             if (this.activeTurn) {
                 this.activeTurn.onParsedMessage(parsed.value);
             }
@@ -943,6 +1118,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 +1194,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 +1285,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 +1307,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 +1329,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 +1459,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 +1506,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 +1729,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 +1776,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 +1791,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 +1861,6 @@ export async function compactWarmCodexThread(input) {
                 if (!compactRequestAccepted) {
                     return;
                 }
-                providerUsage = readCodexCompactionCompletionProviderUsage(message, vitals.threadId)
-                    ?? providerUsage;
                 settleCompaction('compacted');
                 return;
             }
@@ -1605,8 +1873,6 @@ export async function compactWarmCodexThread(input) {
                 if (compactStartedItemId === null || itemId !== compactStartedItemId) {
                     return;
                 }
-                providerUsage = readCodexCompactionCompletionProviderUsage(message, vitals.threadId)
-                    ?? providerUsage;
                 if (compactRequestAccepted) {
                     settleCompaction('compacted');
                 }
@@ -1658,8 +1924,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 +1959,39 @@ 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 readCodexSubagentEffectiveMetadataResult(input) {
+    if (extractCodexThreadIdFromResult(input.result) !== input.threadId) {
+        return null;
+    }
+    const result = readCodexRecord(input.result);
+    if (!result) {
+        return null;
+    }
+    const model = readCodexNonEmptyString(result.model);
+    const modelProvider = readCodexNonEmptyString(result.modelProvider);
+    const serviceTier = result.serviceTier;
+    if (!model ||
+        !modelProvider ||
+        !Object.hasOwn(result, 'serviceTier') ||
+        (serviceTier !== null && serviceTier !== 'flex')) {
+        return null;
+    }
+    return {
+        model,
+        modelProvider,
+        serviceTier,
+    };
 }
 function isCodexTurnCompletedMethod(method) {
-    return method === 'turn/completed' || method === 'turn.completed';
+    return method === 'turn/completed';
 }
 function buildCodexTransportDiagnosticsTraceEvent(input) {
     const source = readCodexTransportDiagnosticSource(input.message, input.method);
@@ -1839,6 +2124,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 +2137,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
@@ -1862,9 +2148,14 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
     let firstAssistantResponseCompleted = false;
     let trailingSteerCandidate = null;
     let completedUserMessageOrdinal = -1;
+    const workoutDeliveryContext = createCodexWorkoutDeliveryContextTracker({
+        contextReferences: input.trustedContextReferences,
+    });
     let lastEventError = null;
     let lastEventErrorInfo = null;
     let responseMedia = [];
+    let responseCard = null;
+    let responseCardTextFallback = null;
     const assistantStyleSettingsOverlay = {
         settings: {},
     };
@@ -1876,25 +2167,43 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
     const reservedNoReplyDeliveryContextOrdinals = new Set();
     const additionalUsages = [];
     let nextDynamicToolUsageOrdinal = (input.providerRequestOrdinal ?? 0) + 1;
-    // Trusted turn-scoped murph.ask_grok provider-call ceiling: one counter per
-    // assistant turn, owned here and threaded into the dynamic-tool executor.
+    // Trusted turn-scoped provider-call ceilings: one counter per assistant turn,
+    // owned here and threaded into the dynamic-tool executor.
+    const analyzeVideoTurnState = createAnalyzeVideoTurnState();
     const askGrokTurnState = createAskGrokTurnState();
-    const subagentTokenUsageByThread = new Map();
-    // Thread ids named by this turn's collab tool calls (spawn/sendInput/...),
-    // collected live so evidenced subagent threads win buffer slots over
-    // stale/unattributed foreign threads when the cap is reached.
-    const collabReceiverThreadIds = new Set();
+    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();
     let rolloutRelativePath = null;
     let providerActionCount = 0;
     const providerActionItemIds = new Set();
     const jsonEvents = [];
     const runtimeIssueInputs = [];
+    const actionRuntimeIssueTracker = createCodexActionRuntimeIssueTracker();
     let computerToolsLockedAfterUserPause = false;
+    let requiredFinalResponseFallback = null;
     const requiredVaultFileApprovalUrls = [];
+    const requiredAutomationLocalAtClarifications = new Map();
     const actionDiagnostics = input.onTraceEvent
         ? createCodexActionDiagnosticsReducer()
         : null;
     let actionDiagnosticsTraceEmitted = false;
+    let requiredFinalResponseFallbackOutcome = null;
     const assistantStreams = new Map();
     const assistantStreamOrder = [];
     const externallyVisibleAssistantOutputDeliveryContexts = new Set();
@@ -1907,7 +2216,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 +2227,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();
@@ -1961,22 +2273,23 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             stderr,
         });
     };
-    // Subagent usage drafts are derived lazily from the buffered per-thread
-    // samples so both the success result and the failure context can include
-    // whatever child usage was observed before the turn settled.
-    const buildSubagentUsageDrafts = () => extractCodexSubagentUsageDrafts({
-        modelProvider: normalizeNullableString(input.modelProvider) ?? null,
-        ordinalStart: nextDynamicToolUsageOrdinal,
-        parentModel: normalizeNullableString(input.model) ?? null,
-        parentRawEvents: jsonEvents,
-        serviceTier: input.serviceTier ?? null,
-        subagentTokenUsageByThread,
-    });
+    const buildSubagentUsageDrafts = () => input.onAdditionalUsage
+        ? []
+        : extractCodexSubagentUsageDrafts({
+            modelProvider: normalizeNullableString(input.modelProvider) ?? null,
+            ordinalStart: nextDynamicToolUsageOrdinal,
+            parentModel: normalizeNullableString(input.model) ?? null,
+            serviceTier: input.serviceTier ?? null,
+            subagentTokenUsageByTurn,
+        });
     const hasNoReplyFinalActionPatch = () => finalActionPatches.some((entry) => entry.patch.kind === 'none');
     const listNoReplyFinalActionPatchOrdinals = () => [...new Set(finalActionPatches
             .filter((entry) => entry.patch.kind === 'none')
             .map((entry) => entry.deliveryContextOrdinal))].sort((left, right) => left - right);
-    const hasRequiredUserVisibleOutput = () => computerToolsLockedAfterUserPause || requiredVaultFileApprovalUrls.length > 0;
+    const hasRequiredUserVisibleOutput = () => computerToolsLockedAfterUserPause ||
+        requiredFinalResponseFallback !== null ||
+        requiredAutomationLocalAtClarifications.size > 0 ||
+        requiredVaultFileApprovalUrls.length > 0;
     const settleNoReplyFinalActions = async () => {
         if (hasRequiredUserVisibleOutput() || noReplySettlementStarted) {
             return;
@@ -2083,7 +2396,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 +2582,53 @@ 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({
+            ...(trailingSteerCandidate.contextReferences === undefined
+                ? {}
+                : {
+                    contextReferences: trailingSteerCandidate.contextReferences,
+                }),
+            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 +2656,7 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
         try {
             contextCompactionProgressPending = true;
             progressPromise = progressDelivery.send(text, {
+                deliveryContextOrdinal,
                 required: true,
                 source: 'system',
             });
@@ -2346,6 +2691,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 +2736,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 +2804,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 +2868,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 +2891,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 +2908,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 +3004,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 +3089,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 +3148,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 +3157,7 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
                 !vaultFileOwnsFinalAction;
             if (shouldSuppressDeliveryContext(dynamicToolRequestDeliveryContextOrdinal) &&
                 !vaultFileMayClassifyAfterGenericNoReply &&
-                isResponseMediaDynamicToolRequest(dynamicToolRequest)) {
+                isResponseAttachmentDynamicToolRequest(dynamicToolRequest)) {
                 return {
                     rpcResult: {
                         contentItems: [{
@@ -2692,7 +3173,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,
@@ -2701,6 +3240,9 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
                 groupRoomModelAvailable: input.dynamicTools.some((tool) => tool.namespace === MURPH_GROUP_ROOM_MODEL_TOOL.namespace &&
                     tool.name === MURPH_GROUP_ROOM_MODEL_TOOL.name),
                 groupRoomModelMaintenanceAuthorized: input.groupRoomModelMaintenanceAuthorized === true,
+                memberMemoryAvailable: input.dynamicTools.some((tool) => tool.namespace === MURPH_MEMBER_MEMORY_TOOL.namespace &&
+                    tool.name === MURPH_MEMBER_MEMORY_TOOL.name),
+                memberMemoryMaintenanceAuthorized: input.memberMemoryMaintenanceAuthorized === true,
                 abortSignal: input.abortSignal
                     ? AbortSignal.any([input.abortSignal, dynamicToolAbortController.signal])
                     : dynamicToolAbortController.signal,
@@ -2710,30 +3252,71 @@ 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
                     : null,
+                analyzeVideoRuntime: dynamicToolRequest.kind === 'analyze-video'
+                    ? input.analyzeVideoRuntime ?? null
+                    : null,
+                analyzeVideoTurnState,
                 askGrokRuntime: dynamicToolRequest.kind === 'ask-grok'
                     ? input.askGrokRuntime ?? null
                     : null,
                 askGrokTurnState,
+                generateSongTurnState,
             });
             return result;
         }).then(async (result) => {
             if (dynamicToolRequest.kind === 'send-progress-update') {
                 releaseDynamicProgressPending?.();
             }
+            if (dynamicToolRequest.kind === 'analyze-video') {
+                const analyzeVideoFallback = normalizeNullableString(result.requiredFinalResponseFallback);
+                if (analyzeVideoFallback !== null) {
+                    if (result.rpcResult.success) {
+                        requiredFinalResponseFallback = analyzeVideoFallback;
+                        requiredFinalResponseFallbackOutcome = 'analyze-video-success';
+                    }
+                    else if (requiredFinalResponseFallbackOutcome !== 'analyze-video-success') {
+                        requiredFinalResponseFallback = analyzeVideoFallback;
+                        requiredFinalResponseFallbackOutcome = 'analyze-video-failure';
+                    }
+                }
+            }
             for (const runtimeIssueInput of result.runtimeIssueInputs ?? []) {
                 pushRuntimeIssueInput(runtimeIssueInput);
             }
@@ -2744,6 +3327,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 +3447,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 +3511,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;
@@ -2870,13 +3532,11 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
                 codexTimingTurnCompletedNotificationElapsedMs = Math.max(0, observedAtMs - providerRequestStartedAtMs);
             }
         }
-        for (const receiverThreadId of readCodexCollabReceiverThreadIds(message)) {
-            collabReceiverThreadIds.add(receiverThreadId);
-        }
         lastEventError = extractCodexErrorMessage(message) ?? lastEventError;
         lastEventErrorInfo = extractCodexErrorInfo(message) ?? lastEventErrorInfo;
         const normalizedEvent = normalizeCodexEvent(message);
-        const runtimeIssueInput = buildRuntimeIssueInputForFailedCodexAction({
+        const runtimeIssueInput = actionRuntimeIssueTracker.recordEvent({
+            activeTurnId: turnId,
             normalizedEvent,
             rawEvent: message,
         });
@@ -2919,6 +3579,10 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             providerActionCount += 1;
         }
         const deliveryContextOrdinal = currentDeliveryContextOrdinal();
+        workoutDeliveryContext.observe({
+            deliveryContextOrdinal,
+            event: normalizedEvent,
+        });
         const suppressDeliveryContext = shouldSuppressDeliveryContext(deliveryContextOrdinal);
         const isCommentaryAssistantMessage = normalizedEvent.kind === 'assistant_message' &&
             normalizedEvent.messagePhase === 'commentary';
@@ -2937,7 +3601,7 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             }
         }
         if (normalizedEvent.kind !== 'status_item' ||
-            normalizedEvent.itemType !== 'context.compaction') {
+            normalizedEvent.itemType !== 'contextCompaction') {
             input.onTraceEvent?.({
                 codexThreadId,
                 rawEvent: message,
@@ -2959,6 +3623,7 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             (completedFinalAgentMessageText !== null ||
                 responseMedia.length > 0);
         if (completedFinalAgentResponse && !suppressDeliveryContext) {
+            workoutDeliveryContext.recordCompletedResponse(deliveryContextOrdinal);
             promoteTrailingSteerCandidate();
             completedFinalAgentMessage = completedFinalAgentMessageText ?? '';
             if (!firstAssistantResponseCompleted) {
@@ -2970,10 +3635,14 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             if (completedFinalAgentMessage !== null) {
                 const completedResponseDeliveryContextOrdinal = Math.max(0, completedUserMessageOrdinal);
                 const completedResponseTargetInputId = resolveReplyTargetPatch(completedResponseDeliveryContextOrdinal)?.targetInputId ?? null;
+                const contextReferences = workoutDeliveryContext.readReferences(completedResponseDeliveryContextOrdinal);
                 trailingSteerCandidate = {
+                    ...(contextReferences === undefined ? {} : { contextReferences }),
                     deliveryContextOrdinal: completedResponseDeliveryContextOrdinal,
                     response: completedFinalAgentMessage,
                     media: [...responseMedia],
+                    card: responseCard,
+                    cardTextFallback: responseCardTextFallback,
                     ...(completedResponseTargetInputId
                         ? { targetInputId: completedResponseTargetInputId }
                         : {}),
@@ -2983,6 +3652,8 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
                 assistantStreamOrder.length = 0;
                 responseMedia = [];
             }
+            responseCard = null;
+            responseCardTextFallback = null;
             completedUserMessageOrdinal += 1;
         }
         const progressEvent = extractCodexProgressEventFromNormalized(normalizedEvent);
@@ -3008,6 +3679,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 +3711,67 @@ 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;
+            }
+            subagentTokenUsageByTurn.set(usageKey, {
+                firstEvent: null,
+                lastEvent: null,
+                occurredAt: new Date().toISOString(),
+                providerRequestOutcome: 'succeeded',
+                threadId,
+                turnId: messageTurnId,
+            });
             return;
         }
-        const sample = subagentTokenUsageByThread.get(threadId);
-        if (sample) {
-            sample.lastEvent = message;
+        if (!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) {
+        const usageKey = createCodexSubagentTurnUsageKey({
+            threadId,
+            turnId: messageTurnId,
+        });
+        const sample = subagentTokenUsageByTurn.get(usageKey);
+        if (isCodexTurnCompletedMethod(eventMethod)) {
+            if (!sample) {
                 return;
             }
-            subagentTokenUsageByThread.delete(evictableThreadId);
+            const status = extractCodexTurnStatus(message);
+            sample.providerRequestOutcome = status === 'interrupted'
+                ? 'aborted'
+                : isFailedCodexTurnStatus(status)
+                    ? 'partial'
+                    : 'succeeded';
+            if (!input.onAdditionalUsage) {
+                return;
+            }
+            // Removing the terminal sample is the exactly-once fence.
+            subagentTokenUsageByTurn.delete(usageKey);
+            if (sample.firstEvent === null || sample.lastEvent === null) {
+                return;
+            }
+            reportSubagentUsage(sample);
+            return;
         }
-        subagentTokenUsageByThread.set(threadId, {
-            firstEvent: message,
-            lastEvent: message,
-        });
+        if (!isAssistantCodexTokenUsageEventType(eventMethod)) {
+            return;
+        }
+        if (!sample) {
+            // A child token sample without an observed start has no accounting timestamp.
+            return;
+        }
+        sample.firstEvent ??= message;
+        sample.lastEvent = message;
     };
     const handleStaleParentTurnMessage = (message) => {
         const requestId = readCodexRpcServerRequestId(message);
@@ -3125,19 +3839,6 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             }
             return;
         }
-        // Codex owns subagent/thread lifecycle. Murph only keeps foreign thread
-        // traffic away from the active parent turn: token usage is buffered for
-        // billing, server requests are denied, and other child events are dropped.
-        // Before a fresh thread/start response produces this turn's thread id, the
-        // previous bound thread id is enough to distinguish late child traffic.
-        const messageThreadId = extractCodexThreadIdFromMessage(message);
-        const knownParentThreadId = codexThreadId ?? requestedResumeThreadId ?? codexProcess.lastBoundThreadId;
-        if (messageThreadId !== null &&
-            knownParentThreadId !== null &&
-            messageThreadId !== knownParentThreadId) {
-            handleSubagentThreadMessage(messageThreadId, message);
-            return;
-        }
         const messageTurnId = extractCodexTurnIdFromMessage(message);
         const method = readCodexEventMethod(message);
         const requestId = readCodexRpcServerRequestId(message);
@@ -3170,10 +3871,23 @@ 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;
+        }
+        if (method === 'rawResponseItem/completed' ||
+            method === 'rawResponse/completed') {
+            // Raw response notifications can contain provider payload content and
+            // do not belong in the parent turn's persisted event surface.
             return;
         }
         handleAcceptedEvent(message, method);
@@ -3205,6 +3919,31 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
         }
     };
     const sendRequest = (method, params) => codexProcess.sendRequest(method, params);
+    const readSubagentEffectiveMetadata = (threadId) => codexProcess.sendRequestWithTimeout({
+        method: 'thread/resume',
+        params: buildCodexThreadMetadataResumeParams(threadId),
+        timeoutLabel: 'thread/resume',
+        timeoutMs: CODEX_BACKGROUND_WORK_RPC_TIMEOUT_MS,
+    }).then((result) => readCodexSubagentEffectiveMetadataResult({ result, threadId })).catch(() => null);
+    const reportSubagentUsage = (sample) => {
+        const ordinal = nextDynamicToolUsageOrdinal++;
+        const report = readSubagentEffectiveMetadata(sample.threadId)
+            .then(async (metadata) => {
+            if (!metadata) {
+                return;
+            }
+            const draft = buildCodexSubagentUsageDraft({
+                metadata,
+                ordinal,
+                sample,
+            });
+            if (draft) {
+                await input.onAdditionalUsage?.(draft);
+            }
+        })
+            .catch(() => undefined);
+        codexProcess.trackDetachedUsageReport(report);
+    };
     const requireLiveTurnIds = () => {
         if (!liveTurnOpen || !codexThreadId || !turnId) {
             throw buildLiveTurnInactiveError();
@@ -3216,15 +3955,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 +3987,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 ||
@@ -3278,6 +4044,12 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             }));
         },
         onParsedMessage: handleParsedMessage,
+        onSubagentMessage(message) {
+            const threadId = extractCodexThreadIdFromMessage(message);
+            if (threadId) {
+                handleSubagentThreadMessage(threadId, message);
+            }
+        },
         onStderrLine(line) {
             const progressEvent = extractCodexStatusEventFromStderrLine(line);
             if (progressEvent) {
@@ -3301,7 +4073,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';
@@ -3323,12 +4099,6 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
                 threadResult,
             });
         }
-        else if (normalizeNullableString(input.permissions)) {
-            assertCodexThreadStartPermissionAttestation({
-                input,
-                threadResult,
-            });
-        }
         codexThreadId = extractCodexThreadIdFromResult(threadResult) ?? codexThreadId;
         codexProcess.noteBoundThreadId(codexThreadId);
         rolloutRelativePath = resolveCodexRolloutRelativePath({
@@ -3347,26 +4117,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 +4184,7 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
             ? (buildRecordedTerminationError(lastEventError) ?? error)
             : error;
         emitActionDiagnosticsTrace();
+        await drainPendingDynamicToolRequests();
         dynamicToolAbortController.abort();
         await drainPendingDynamicToolExecutions();
         await drainPendingProgressDeliveries();
@@ -3454,7 +4227,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 +4240,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 +4272,30 @@ 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 requiredSemanticFinalMessage = normalizeNullableString(semanticFinalMessage) ??
+        requiredFinalResponseFallback ??
+        semanticFinalMessage;
+    const requiredAutomationLocalAtClarificationsInOrder = [...requiredAutomationLocalAtClarifications.values()];
+    const deliveredFinalResponseCard = requiredAutomationLocalAtClarificationsInOrder.length === 0
+        ? finalResponseCard
+        : null;
+    const finalMessage = appendRequiredVaultFileApprovalUrls(appendRequiredAutomationLocalAtClarification(requiredSemanticFinalMessage, requiredAutomationLocalAtClarificationsInOrder), requiredVaultFileApprovalUrls);
+    const semanticTranscriptMessage = finalResponseCard
+        ? requiredAutomationLocalAtClarificationsInOrder.length === 0
+            ? renderAssistantResponseCardTranscriptText(finalResponseCard)
+            : renderAssistantResponseCardText(finalResponseCard)
+        : finalResponseCardTextFallback
+            ? renderAssistantWorkoutResponseCardTranscriptText(finalResponseCardTextFallback)
+            : normalizeNullableString(modelFinalMessage) ??
+                (finalResponseMedia.length > 0 ? '' : null);
+    const transcriptMessage = appendRequiredAutomationLocalAtClarification(normalizeNullableString(semanticTranscriptMessage) ??
+        requiredFinalResponseFallback ??
+        semanticTranscriptMessage, requiredAutomationLocalAtClarificationsInOrder);
     if (noReplySelected &&
         normalizeNullableString(extractedFinalMessage) !== null) {
         emitCodexSuppressedFinalMessageTrace({
@@ -3493,31 +4308,44 @@ 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));
+    const finalResponseContextReferences = workoutDeliveryContext.readReferences(finalDeliveryContextOrdinal);
     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,
             targetInputId: entry.patch.targetInputId,
         })),
         precedingAgentMessageSegments: filteredPrecedingAgentMessageSegments.map((segment) => ({
+            ...(segment.contextReferences === undefined
+                ? {}
+                : { contextReferences: segment.contextReferences }),
             deliveryContextOrdinal: segment.deliveryContextOrdinal,
             response: segment.response,
+            ...(segment.transcriptResponse === undefined
+                ? {}
+                : { transcriptResponse: segment.transcriptResponse }),
             media: [...segment.media],
             ...(segment.targetInputId
                 ? { targetInputId: segment.targetInputId }
                 : {}),
         })),
         responseDeliveryContextOrdinal: finalDeliveryContextOrdinal,
+        ...(finalResponseContextReferences === undefined
+            ? {}
+            : { responseContextReferences: finalResponseContextReferences }),
         targetInputId: resolveReplyTargetPatch(finalDeliveryContextOrdinal)?.targetInputId ?? null,
         additionalUsages: [...additionalUsages, ...buildSubagentUsageDrafts()],
         responseMedia: finalHasDeliverableOutput ? [...finalResponseMedia] : [],
+        responseCard: finalHasDeliverableOutput ? deliveredFinalResponseCard : null,
         jsonEvents,
         providerActionCount,
         runtimeIssueInputs,
@@ -3529,44 +4357,22 @@ async function runCodexAppServerTurnOnProcess(codexProcess, input) {
         turnId,
     };
 }
-function assertCodexThreadStartPermissionAttestation(input) {
-    const result = asCodexRecord(input.threadResult);
-    const activePermissionProfile = asCodexRecord(result?.activePermissionProfile);
-    const actualCwd = normalizeNullableString(asCodexString(result?.cwd));
-    const actualRoots = asCodexStringArray(result?.runtimeWorkspaceRoots);
-    const instructionSources = Array.isArray(result?.instructionSources)
-        ? result.instructionSources
-        : null;
-    const expectedRoots = input.input.runtimeWorkspaceRoots ?? [];
-    const mismatchedFields = [];
-    const permissionProfileMismatch = normalizeNullableString(asCodexString(activePermissionProfile?.id)) !==
-        normalizeNullableString(input.input.permissions) ||
-        normalizeNullableString(asCodexString(activePermissionProfile?.extends)) !== null;
-    if (permissionProfileMismatch) {
-        mismatchedFields.push('activePermissionProfile');
-    }
-    if (!actualRoots ||
-        actualRoots.length !== expectedRoots.length ||
-        actualRoots.some((root, index) => path.resolve(root) !== path.resolve(expectedRoots[index] ?? ''))) {
-        mismatchedFields.push('runtimeWorkspaceRoots');
-    }
-    if (!actualCwd || path.resolve(actualCwd) !== input.input.workingDirectory) {
-        mismatchedFields.push('cwd');
-    }
-    if (instructionSources === null || instructionSources.length !== 0) {
-        mismatchedFields.push('instructionSources');
+function mergeAutomationRelativeDateReferenceWindows(preceding, current) {
+    if (current === null) {
+        return null;
     }
-    if (asCodexString(result?.approvalPolicy) !==
-        mapCodexAppServerApprovalPolicy(input.input.approvalPolicy)) {
-        mismatchedFields.push('approvalPolicy');
+    if (preceding === null) {
+        return { ...current };
     }
-    if (mismatchedFields.length === 0) {
-        return;
+    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;
     }
-    throw new VaultCliError('ASSISTANT_CODEX_APP_SERVER_PERMISSION_ATTESTATION_FAILED', 'Codex app-server did not attest the requested read-only execution context.', {
-        mismatchedFields,
-        retryable: false,
-    });
+    return {
+        earliestAt: new Date(earliestAtMs).toISOString(),
+        latestAt: new Date(latestAtMs).toISOString(),
+    };
 }
 function emitCodexSuppressedFinalMessageTrace(input) {
     if (!input.onTraceEvent) {
@@ -3588,6 +4394,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;
@@ -3605,37 +4441,44 @@ function notifyCodexAppServerProviderRequestStartedBestEffort(input) {
     }
 }
 function isInvalidDynamicToolRequest(request) {
-    return (request.kind === 'invalid-generate-image-arguments' ||
-        request.kind === 'invalid-automation-arguments' ||
-        request.kind === 'invalid-assistant-style-arguments' ||
-        request.kind === 'invalid-computer-arguments' ||
-        request.kind === 'invalid-device-arguments' ||
-        request.kind === 'invalid-generate-voice-memo-arguments' ||
-        request.kind === 'invalid-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-media-arguments');
+    return 'validationDigest' in request;
 }
 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 +4486,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 +4573,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 +4593,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 +4677,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 +4697,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) {