@murphai/murph 1.3.0 → 1.3.2

package/node_modules/@murphai/assistant-engine/dist/assistant/local-service.js

@@ -1,10 +1,12 @@
 import { assistantAskResultSchema, } from '@murphai/operator-config/assistant-cli-contracts';
+import { renderAssistantResponseCardTranscriptText, renderAssistantResponseCardText, } from '@murphai/operator-config/assistant-response-cards';
 import { assistantBackendTargetToProviderConfigInput, createAssistantModelTarget, createDefaultLocalAssistantModelTarget, } from '@murphai/operator-config/assistant-backend';
+import { CAPTURE_LOOKUP_INDEX_PATH, readStoredCaptureLookupIndex, } from '@murphai/core';
 import { appendAssistantTranscriptEntries, appendAssistantTranscriptEntriesWithRefs, redactAssistantDisplayPath, resolveAssistantSession, saveAssistantSession, } from './store.js';
 import { resolveAssistantConversationLookupKey } from './store/paths.js';
 import { resolveAssistantOperatorDefaults } from '@murphai/operator-config/operator-config';
 import { normalizeAssistantDeliveryError, } from './outbox.js';
-import { ASSISTANT_IMAGE_RESPONSE_TRANSCRIPT_MARKER, } from './response-media.js';
+import { ASSISTANT_IMAGE_RESPONSE_TRANSCRIPT_MARKER, resolveAssistantGeneratedImageDelivery, } from './response-media.js';
 import { recordAssistantDiagnosticEvent } from './diagnostics.js';
 import { refreshAssistantStatusSnapshotLocal } from './status.js';
 import { resolveAssistantTurnSharedPlan as buildAssistantTurnSharedPlan, } from './turn-plan.js';
@@ -13,16 +15,15 @@ import { emitHostedAssistantContextTimingTrace, emitHostedAssistantContextSessio
 import { emitHostedAssistantTurnTimingTrace } from './hosted-turn-timing.js';
 import { deliverAssistantPrecedingReplies, deliverAssistantReaction, deliverAssistantReply as dispatchAssistantReply, deliverAssistantProgressUpdate, finalizeAssistantTurnFromDeliveryOutcome as finalizeDeliveredAssistantTurn, resolveAssistantCurrentAudienceDeliveryFields, resolveAssistantHostedDeliveryIdempotency, } from './delivery-service.js';
 import { applyAssistantReplyDeliveryContext, applyAssistantReplyDeliveryContextOverrides, pickAssistantReplyDeliveryContext, } from './reply-delivery-context.js';
-import { applyAssistantSessionCodexResumeStateAction, clearAssistantSessionCodexResumeState, persistAssistantNoReplyTranscriptMarkers, persistAssistantTurnAndSession as finalizeAssistantTurnArtifacts, resolveAssistantProviderResumeStateAction, } from './turn-finalizer.js';
+import { applyAssistantSessionCodexResumeStateAction, clearAssistantSessionCodexResumeState, persistAssistantNoReplyTranscriptMarkers, persistAssistantTurnAndSession as finalizeAssistantTurnArtifacts, resolveAssistantProviderResumeStateAction, resolveAssistantResumeStateFromProviderTurn, } from './turn-finalizer.js';
 import { bindAssistantResumeStateToThreadCompatibility, } from './codex-resume-binding.js';
 import { readAssistantCodexResume, } from './conversation-persistence.js';
 import { appendAssistantTurnReceiptEvent, createAssistantTurnReceipt, finalizeAssistantTurnReceipt, } from './turns.js';
-import { mergeAssistantProviderConfigsForProvider, serializeAssistantProviderSessionOptions, } from '@murphai/operator-config/assistant/provider-config';
+import { mergeAssistantProviderConfigs, serializeAssistantProviderSessionOptions, } from '@murphai/operator-config/assistant/provider-config';
 import { VaultCliError } from '@murphai/operator-config/vault-cli-errors';
-import { normalizeAssistantExecutionContext, } from './execution-context.js';
-import { resolveAssistantExecutionDefaultTarget } from './execution-context.js';
-import { resolveAssistantExecutionOperatorDefaults } from './execution-context.js';
+import { normalizeAssistantExecutionContext, resolveAssistantExecutionDefaultTarget, resolveAssistantExecutionOperatorDefaults, } from './execution-context.js';
 import { executeCodexTurnWithRecovery, resolveAssistantCodexThreadScope, } from './codex-turn-runner.js';
+import { stampAssistantProviderStartCriticalPath, } from './provider-start-critical-path.js';
 import { readCodexThreadCompatibilityFingerprint, readCodexThreadRouteFingerprint, } from './codex-thread-route.js';
 import { resolveAssistantExecutionPlan } from './execution-plan.js';
 import { normalizeAssistantAskResultForReturn, serializeAssistantSessionForResult, } from './service-result.js';
@@ -35,6 +36,7 @@ import { assistantDeliveryOutcomeSupersedesTypingIndicator, startAssistantChanne
 import { createAssistantProgressDelivery, resolveAssistantProductFeedbackAcceptedInputIds, shouldCreateAssistantProgressDelivery, } from './turn-progress.js';
 import { createAssistantHostedToolContext, } from './hosted-tool-context.js';
 import { resolveAssistantUserActionAcceptedInputIds, } from '../assistant-codex/dynamic-tools/phone-calls.js';
+import { snapshotAnalyzeVideoAttachmentAuthorities, } from '../assistant-codex/analyze-video-tool.js';
 import { createAssistantRuntimeStateService } from './runtime-state-service.js';
 import { requestAssistantVaultFileSend, resolveAssistantVaultFileSendTargetFingerprint, } from './vault-file-send.js';
 import { assertAssistantAcceptedTurnInputAssistantInputEventsExist, assertAssistantAcceptedTurnInputItemInputsAssistantInputEventsExist, } from './active-turn-input-journal.js';
@@ -48,6 +50,87 @@ import { withAssistantTurnLock } from './turn-lock.js';
 export { buildResolveAssistantSessionInput } from './session-resolution.js';
 const DEFAULT_INITIAL_ACCEPTED_TURN_INPUT_ID = 'initial';
 const PHONE_CALL_MANUAL_ACCEPTED_TURN_INPUT_ID_PREFIX = 'manual-phone-call:';
+const ASSISTANT_GROUP_REPLY_RECONSIDERATION_INSTRUCTION = [
+    'Additional group messages joined this turn.',
+    'Replace the draft with one final result under the group turn rules.',
+    'The unsent draft neither answers a request nor keeps Murph\'s floor; the latest accepted message decides who owns the updated beat.',
+    'If the latest accepted message gives another human the floor, finish without a reply.',
+    'Treat every request answered only in the unsent draft as unanswered; if Murph still owns the beat, include every still-relevant answer in the final result. Response text is not a completed effect.',
+    'Do not repeat completed effects or mention the draft or this instruction.',
+].join(' ');
+function shouldHoldAssistantGroupReplyDraft(input) {
+    const channel = normalizeNullableString(input.plan.conversationPolicy.audience.channel)?.toLowerCase() ?? normalizeNullableString(input.message.channel)?.toLowerCase();
+    return (input.message.deliverResponse === true &&
+        input.message.turnTrigger === 'automation-auto-reply' &&
+        input.message.scheduledOccurrenceAt == null &&
+        input.message.scheduledInvocationAuthority == null &&
+        resolveAssistantConversationScope(input.plan.conversationPolicy.audience) === 'group' &&
+        (channel === 'linq' || channel === 'telegram'));
+}
+function appendAssistantTurnContext(current, addition) {
+    return [normalizeNullableString(current), addition]
+        .filter((part) => part !== null)
+        .join('\n\n');
+}
+function applyAssistantProviderTurnResumeInMemory(input) {
+    const resumeState = resolveAssistantResumeStateFromProviderTurn({
+        assistantContractFingerprint: input.providerResult.assistantContractFingerprint,
+        codexRolloutRelativePath: input.providerResult.codexRolloutRelativePath,
+        codexThreadId: input.providerResult.codexThreadId,
+        routeFingerprint: readCodexThreadRouteFingerprint(input.providerResult.route),
+        threadCompatibilityFingerprint: readCodexThreadCompatibilityFingerprint(input.providerResult.route),
+    });
+    if (!resumeState) {
+        throw new VaultCliError('ASSISTANT_GROUP_DRAFT_CONTINUATION_UNAVAILABLE', 'The unsent group reply could not be reconsidered in the same provider thread.');
+    }
+    return {
+        ...input.session,
+        codexResume: resumeState,
+        resumeState,
+    };
+}
+function rebaseAssistantProviderResultDeliveryContexts(input) {
+    if (input.baseOrdinal === 0) {
+        return input.providerResult;
+    }
+    return {
+        ...input.providerResult,
+        acceptedNoReplyDeliveryContextOrdinals: input.providerResult.acceptedNoReplyDeliveryContextOrdinals?.map((ordinal) => ordinal + input.baseOrdinal),
+        precedingResponseSegments: input.providerResult.precedingResponseSegments?.map((segment) => ({
+            ...segment,
+            deliveryContextOrdinal: segment.deliveryContextOrdinal + input.baseOrdinal,
+        })),
+        reactions: input.providerResult.reactions?.map((reaction) => ({
+            ...reaction,
+            deliveryContextOrdinal: reaction.deliveryContextOrdinal + input.baseOrdinal,
+        })),
+        responseDeliveryContextOrdinal: input.providerResult.responseDeliveryContextOrdinal + input.baseOrdinal,
+    };
+}
+function selectAssistantGroupProviderResult(providerResult) {
+    const noReplySelected = providerResult.finalAction?.kind === 'none';
+    return {
+        ...providerResult,
+        acceptedNoReplyDeliveryContextOrdinals: noReplySelected
+            ? [
+                providerResult.acceptedNoReplyDeliveryContextOrdinals?.at(-1)
+                    ?? providerResult.responseDeliveryContextOrdinal,
+            ]
+            : [],
+        precedingResponseSegments: [],
+        reactions: noReplySelected
+            ? providerResult.reactions?.slice(-1)
+            : [],
+        ...(noReplySelected
+            ? {
+                response: '',
+                responseCard: null,
+                responseMedia: [],
+                transcriptResponse: null,
+            }
+            : {}),
+    };
+}
 function resolveAssistantProgressDeliveryChannel(input) {
     return normalizeNullableString(input.sharedPlan.conversationPolicy.audience.channel)
         ?? normalizeNullableString(input.session.binding.channel);
@@ -165,6 +248,16 @@ async function persistUserTurn(input, resolved, plan, turnId) {
     };
 }
 const UNVERIFIED_EXTERNAL_AUDIENCE_RESPONSE = "I couldn't verify whether this is a private or group conversation, so I can't safely use account context here yet. Please try again in your private chat with Murph.";
+const UNVERIFIED_EXTERNAL_SUPPORT_CONTACT_RESPONSE = `${UNVERIFIED_EXTERNAL_AUDIENCE_RESPONSE} You can email support@withmurph.ai.`;
+function resolveUnverifiedExternalAudienceResponse(prompt) {
+    const asksForSupportContact = /\bsupport\b/iu.test(prompt)
+        && /\b(?:address|contact|e-?mail|reach)\b/iu.test(prompt)
+        && (/[?]/u.test(prompt)
+            || /\b(?:give|how|need|please|send|share|tell|want|what|where)\b/iu.test(prompt));
+    return asksForSupportContact
+        ? UNVERIFIED_EXTERNAL_SUPPORT_CONTACT_RESPONSE
+        : UNVERIFIED_EXTERNAL_AUDIENCE_RESPONSE;
+}
 async function completeUnverifiedExternalAudienceTurn(input) {
     let turnCreatedAt = input.userTurn.turnCreatedAt;
     if (!input.userTurn.userPersisted) {
@@ -181,7 +274,7 @@ async function completeUnverifiedExternalAudienceTurn(input) {
     await appendAssistantTranscriptEntries(input.message.vault, input.session.sessionId, [{
             createdAt: turnCreatedAt,
             kind: 'assistant',
-            text: UNVERIFIED_EXTERNAL_AUDIENCE_RESPONSE,
+            text: input.response,
         }]);
     const updatedAt = new Date().toISOString();
     const savedSession = await saveAssistantSession(input.message.vault, {
@@ -192,14 +285,14 @@ async function completeUnverifiedExternalAudienceTurn(input) {
     });
     const outcome = await dispatchAssistantReply({
         input: input.message,
-        response: UNVERIFIED_EXTERNAL_AUDIENCE_RESPONSE,
+        response: input.response,
         session: savedSession,
         sharedPlan: input.plan,
         turnId: input.turnId,
     });
     await finalizeDeliveredAssistantTurn({
         outcome,
-        response: UNVERIFIED_EXTERNAL_AUDIENCE_RESPONSE,
+        response: input.response,
         turnId: input.turnId,
         vault: input.message.vault,
     });
@@ -216,7 +309,7 @@ async function completeUnverifiedExternalAudienceTurn(input) {
                 : null,
             media: outcome.media,
             prompt: input.message.prompt,
-            response: UNVERIFIED_EXTERNAL_AUDIENCE_RESPONSE,
+            response: input.response,
             session: outcome.session,
             status: 'completed',
             vault: redactAssistantDisplayPath(input.message.vault),
@@ -228,6 +321,7 @@ export async function openAssistantConversationLocal(input) {
     return resolveAssistantSession(buildResolveAssistantSessionInput(input, defaults, createDefaultLocalAssistantModelTarget()));
 }
 export async function sendAssistantMessageLocal(input) {
+    const providerStartAtAssistantService = stampAssistantProviderStartCriticalPath(input.providerStartCriticalPath, 'assistantServiceStartedAtMonotonicMs');
     await assertAssistantAcceptedTurnInputItemInputsAssistantInputEventsExist({
         inputs: input.acceptedTurnInput?.initialInputs ?? [],
         vault: input.vault,
@@ -254,11 +348,13 @@ export async function sendAssistantMessageLocal(input) {
         defaults: await resolveAssistantOperatorDefaults(),
         executionContext,
     });
+    const providerStartAtTurnLockWait = stampAssistantProviderStartCriticalPath(providerStartAtAssistantService, 'assistantTurnLockWaitStartedAtMonotonicMs');
     const turnLockWaitStartedAt = Date.now();
     const runLockedTurn = () => withAssistantTurnLock({
         abortSignal: input.abortSignal,
         vault: input.vault,
         run: async () => {
+            const providerStartAtTurnLockAcquired = stampAssistantProviderStartCriticalPath(providerStartAtTurnLockWait, 'assistantTurnLockAcquiredAtMonotonicMs');
             const lockAcquiredAt = Date.now();
             const turnLockWaitMs = elapsedSince(turnLockWaitStartedAt);
             emitHostedAssistantContextTimingTrace({
@@ -280,6 +376,10 @@ export async function sendAssistantMessageLocal(input) {
             });
             const promptBuildStartedAt = Date.now();
             const sharedPlan = await buildAssistantTurnSharedPlan(input, resolved);
+            const holdGroupReplyDraft = shouldHoldAssistantGroupReplyDraft({
+                message: input,
+                plan: sharedPlan,
+            });
             const promptBuildMs = elapsedSince(promptBuildStartedAt);
             const route = resolveAssistantTurnRoute(input, defaults, resolved);
             const receipt = await createAssistantTurnReceipt({
@@ -312,13 +412,15 @@ export async function sendAssistantMessageLocal(input) {
             };
             let currentSession = resolved.session;
             let deliverySupersededTypingIndicator = false;
+            let providerRequestOrdinal = 0;
             try {
                 if (resolveAssistantConversationScope(sharedPlan.conversationPolicy.audience) === 'unverified-external') {
                     userTurn = await persistUserTurn(input, resolved, sharedPlan, receipt.turnId);
-                    responseText = UNVERIFIED_EXTERNAL_AUDIENCE_RESPONSE;
+                    responseText = resolveUnverifiedExternalAudienceResponse(input.prompt);
                     const completed = await completeUnverifiedExternalAudienceTurn({
                         message: input,
                         plan: sharedPlan,
+                        response: responseText,
                         session: resolved.session,
                         turnId: receipt.turnId,
                         userTurn,
@@ -327,17 +429,61 @@ export async function sendAssistantMessageLocal(input) {
                         assistantDeliveryOutcomeSupersedesTypingIndicator(completed.outcome.kind);
                     return completed.result;
                 }
+                const runtimeState = createAssistantRuntimeStateService(input.vault);
+                const analyzeVideoAttachmentAuthorities = new Map();
+                const snapshottedAnalyzeVideoInputIds = new Set();
+                const snapshotAnalyzeVideoAuthorities = async (acceptedInputIds) => {
+                    const newInputIds = acceptedInputIds.filter((acceptedInputId) => {
+                        if (snapshottedAnalyzeVideoInputIds.has(acceptedInputId)) {
+                            return false;
+                        }
+                        snapshottedAnalyzeVideoInputIds.add(acceptedInputId);
+                        return true;
+                    });
+                    if (newInputIds.length === 0)
+                        return;
+                    const authorities = await snapshotAnalyzeVideoAttachmentAuthorities({
+                        acceptedInputIds: newInputIds,
+                        vaultRoot: input.vault,
+                    });
+                    for (const authority of authorities) {
+                        const key = JSON.stringify([
+                            authority.messageRef,
+                            authority.ordinal,
+                        ]);
+                        if (!analyzeVideoAttachmentAuthorities.has(key)) {
+                            analyzeVideoAttachmentAuthorities.set(key, authority);
+                        }
+                    }
+                };
+                const preProviderSteerAcceptedInputJournals = new Map();
                 const turnInputController = createAssistantActiveTurnInputController({
                     acceptedInputValidator: async ({ acceptedInputs }) => {
                         await assertAssistantAcceptedTurnInputItemInputsAssistantInputEventsExist({
                             inputs: acceptedInputs,
                             vault: input.vault,
                         });
+                        await snapshotAnalyzeVideoAuthorities(acceptedInputs.map((acceptedInput) => acceptedInput.id));
                     },
                     admissionHook: input.activeTurnInput,
                     beforeProviderSteer: input.beforeProviderAcceptedInputs
                         ? async (event) => {
-                            await input.beforeProviderAcceptedInputs?.(event);
+                            const acceptedInputJournal = await runtimeState.turns.acceptedInputs.append({
+                                inputs: event.acceptedInputs,
+                                sessionId: resolved.session.sessionId,
+                                turnId: receipt.turnId,
+                            });
+                            await assertAssistantAcceptedTurnInputAssistantInputEventsExist({
+                                journal: acceptedInputJournal,
+                                vault: input.vault,
+                            });
+                            await snapshotAnalyzeVideoAuthorities(acceptedInputJournal.inputIds);
+                            const releaseProviderAcceptedInputs = await input.beforeProviderAcceptedInputs?.({
+                                ...event,
+                                turnId: receipt.turnId,
+                            });
+                            preProviderSteerAcceptedInputJournals.set(JSON.stringify(event.acceptedInputs.map((item) => item.id)), acceptedInputJournal);
+                            return releaseProviderAcceptedInputs;
                         }
                         : undefined,
                     conversationKeys: [
@@ -345,13 +491,13 @@ export async function sendAssistantMessageLocal(input) {
                         resolveAssistantConversationLookupKey(input),
                     ].filter((key) => key !== null),
                     sessionId: resolved.session.sessionId,
+                    signal: input.abortSignal,
                     turnId: receipt.turnId,
                     vault: input.vault,
                 });
                 activeTurnInputController = turnInputController;
                 userTurn = await persistUserTurn(input, resolved, sharedPlan, receipt.turnId);
                 let currentUserTurn = userTurn;
-                const runtimeState = createAssistantRuntimeStateService(input.vault);
                 const initialAcceptedTurnInputItems = resolveInitialAcceptedTurnInputItems({
                     input,
                     resolved,
@@ -370,6 +516,7 @@ export async function sendAssistantMessageLocal(input) {
                     journal: initialAcceptedInputJournal,
                     vault: input.vault,
                 });
+                await snapshotAnalyzeVideoAuthorities(initialAcceptedInputJournal.inputIds);
                 const threadScope = resolveAssistantCodexThreadScope({});
                 const turnTimingStartedAt = lockAcquiredAt;
                 let currentInput = input;
@@ -391,7 +538,7 @@ export async function sendAssistantMessageLocal(input) {
                 let acceptedInputIdsForProviderRequest = initialAcceptedInputJournal.inputIds;
                 let acceptedInputItemsForProviderRequest = initialAcceptedInputJournal.inputs;
                 let providerRequestAcceptedInputIds = initialAcceptedInputJournal.inputIds;
-                let beforeHostedToolExecution = async () => { };
+                let beforeHostedToolExecution = async (_throughDeliveryContextOrdinal) => { };
                 const refreshTypingIndicatorAfterProgress = () => {
                     void runAssistantTurnBestEffort(async () => {
                         await typingIndicator?.refreshAfterMessage?.();
@@ -401,10 +548,30 @@ export async function sendAssistantMessageLocal(input) {
                     hostedOptionalProgressDeliveryAvailable
                     ? createAssistantProgressDelivery({
                         deliver: async (progressInput) => {
+                            const deliveryContextOrdinal = progressInput.deliveryContextOrdinal ?? 0;
+                            const absoluteDeliveryContextOrdinal = providerRequestDeliveryContextBaseOrdinal +
+                                deliveryContextOrdinal;
+                            const { targetInputId, ...untargetedProgressInput } = progressInput;
+                            if (targetInputId) {
+                                await beforeHostedToolExecution(deliveryContextOrdinal);
+                            }
+                            const resolvedProgressInput = targetInputId
+                                ? {
+                                    ...untargetedProgressInput,
+                                    input: await applyAssistantAcceptedMessageTargetToDeliveryInput({
+                                        acceptedInputIds: resolveAcceptedInputIdsThroughDeliveryContextOrdinal(absoluteDeliveryContextOrdinal),
+                                        action: 'native-reply',
+                                        input: progressInput.input,
+                                        session: progressInput.session,
+                                        sharedPlan,
+                                        targetInputId,
+                                    }),
+                                }
+                                : untargetedProgressInput;
                             const hosted = hostedExecutionContext;
                             if (hosted) {
                                 const dependencies = hosted.progressDeliveryDependencies;
-                                const progressChannel = resolveAssistantProgressDeliveryChannel(progressInput);
+                                const progressChannel = resolveAssistantProgressDeliveryChannel(resolvedProgressInput);
                                 if (!dependencies ||
                                     !hasHostedTextDeliveryForChannel({
                                         channel: progressChannel,
@@ -416,7 +583,7 @@ export async function sendAssistantMessageLocal(input) {
                                     ? dependencies.sendLinq
                                     : undefined;
                                 if (sendLinq) {
-                                    await beforeHostedToolExecution();
+                                    await beforeHostedToolExecution(deliveryContextOrdinal);
                                 }
                                 const progressDependencies = sendLinq
                                     ? {
@@ -430,14 +597,14 @@ export async function sendAssistantMessageLocal(input) {
                                     }
                                     : dependencies;
                                 const result = await deliverAssistantProgressUpdate({
-                                    ...progressInput,
+                                    ...resolvedProgressInput,
                                     dependencies: progressDependencies,
                                 });
                                 refreshTypingIndicatorAfterProgress();
                                 return result;
                             }
                             const result = await deliverAssistantProgressUpdate({
-                                ...progressInput,
+                                ...resolvedProgressInput,
                             });
                             refreshTypingIndicatorAfterProgress();
                             return result;
@@ -474,15 +641,21 @@ export async function sendAssistantMessageLocal(input) {
                     && actionApprovalPort != null
                     && currentDeliveryFields.channel?.trim().toLowerCase() === 'linq'
                     && vaultFileSendTargetFingerprint !== null;
+                const pendingVaultFilesAvailable = input.deliverResponse === true
+                    && currentAudienceReplyDeliveryAvailable
+                    && currentDeliveryFields.channel?.trim().toLowerCase() === 'linq';
                 const hostedToolContext = hostedExecutionContext
                     ? createAssistantHostedToolContext({
                         computerToolsAvailable: hostedComputerToolsAvailable,
-                        beforeToolExecution: () => beforeHostedToolExecution(),
+                        beforeToolExecution: (deliveryContextOrdinal) => beforeHostedToolExecution(deliveryContextOrdinal),
                         executionContext: hostedExecutionContext,
                         getDeliveryContext: () => ({
                             messageInput: currentInput,
                             session: currentSession,
                         }),
+                        getAnalyzeVideoAttachmentAuthorities: () => [
+                            ...analyzeVideoAttachmentAuthorities.values(),
+                        ],
                         getConversationScope: () => resolveAssistantConversationScope(sharedPlan.conversationPolicy.audience),
                         getUserActionAcceptedInputIds: () => resolveAssistantUserActionAcceptedInputIds({
                             acceptedInputItems: acceptedInputItemsForProviderRequest,
@@ -490,10 +663,47 @@ export async function sendAssistantMessageLocal(input) {
                         }),
                         getProductFeedbackAcceptedInputIds: () => resolveAssistantProductFeedbackAcceptedInputIds(acceptedInputItemsForProviderRequest),
                         messageInput: input,
+                        pendingVaultFilesAvailable,
+                        verifyGeneratedImageDelivery: async (candidate) => {
+                            try {
+                                const imageRef = candidate.imageRef;
+                                const knownFromCurrentCompletion = currentInput.hostedImageCompletionEffectRestriction
+                                    ?.exactMedia?.some((media) => media.ref === imageRef) === true;
+                                const [intents, transcriptEntries, captureLookupIndex] = await Promise.all([
+                                    runtimeState.outbox.listIntents(),
+                                    runtimeState.transcripts.list(currentSession.sessionId),
+                                    (async () => {
+                                        await hostedExecutionContext
+                                            ?.materializeWorkspaceArtifacts?.([
+                                            CAPTURE_LOOKUP_INDEX_PATH,
+                                        ]);
+                                        return await readStoredCaptureLookupIndex({
+                                            vaultRoot: input.vault,
+                                        });
+                                    })(),
+                                ]);
+                                return resolveAssistantGeneratedImageDelivery({
+                                    currentMedia: {
+                                        contentType: candidate.contentType,
+                                        sha256: candidate.sha256,
+                                        sizeBytes: candidate.sizeBytes,
+                                    },
+                                    generatedImageOriginKnown: knownFromCurrentCompletion ||
+                                        Object.values(captureLookupIndex.entries).some((entry) => entry.attachmentRef === imageRef),
+                                    imageRef,
+                                    intents,
+                                    sessionId: currentSession.sessionId,
+                                    transcriptEntries,
+                                });
+                            }
+                            catch {
+                                return false;
+                            }
+                        },
                         route,
                         ...(vaultFileSendAvailable && actionApprovalPort
                             ? {
-                                sendVaultFile: async (ref, toolCallId) => {
+                                sendVaultFile: async (ref, toolCallId, retireExportPackIds) => {
                                     const deliveryFields = resolveAssistantCurrentAudienceDeliveryFields({
                                         input: currentInput,
                                         session: currentSession,
@@ -523,6 +733,7 @@ export async function sendAssistantMessageLocal(input) {
                                         explicitTarget: deliveryFields.explicitTarget,
                                         identityId: deliveryFields.identityId,
                                         ref,
+                                        retireExportPackIds,
                                         replyToMessageId: deliveryFields.replyToMessageId,
                                         sessionId: currentSession.sessionId,
                                         threadId: deliveryFields.threadId,
@@ -562,7 +773,9 @@ export async function sendAssistantMessageLocal(input) {
                     : null;
                 let providerResult = null;
                 let userPromptPersistedToTranscript = currentUserTurn.userPersisted;
-                const providerRequestOrdinal = 0;
+                let providerRequestDeliveryContextBaseOrdinal = 0;
+                let nextUsageRecordOrdinal = 0;
+                const heldGroupAcceptedTranscriptInputs = [];
                 const persistInitialUserPromptToTranscriptIfNeeded = async (persistInput) => {
                     if (userPromptPersistedToTranscript) {
                         return;
@@ -596,47 +809,68 @@ export async function sendAssistantMessageLocal(input) {
                         });
                     }
                 };
+                const persistAcceptedActiveTurnInputTranscripts = async (persistInput) => {
+                    const transcriptRefsByInputId = await appendAcceptedActiveTurnInputTranscriptEntries({
+                        acceptedInput: persistInput.acceptedInput,
+                        acceptedInputItems: persistInput.acceptedInputItems,
+                        sessionId: resolved.session.sessionId,
+                        turnId: currentUserTurn.turnId,
+                        vault: currentInput.vault,
+                    });
+                    const transcriptRefUpdates = resolveAcceptedTurnInputTranscriptRefUpdates({
+                        inputs: persistInput.acceptedInputItems,
+                        transcriptRefsByInputId,
+                    });
+                    if (transcriptRefUpdates.length > 0) {
+                        await runtimeState.turns.acceptedInputs.updateTranscriptRefs({
+                            refs: transcriptRefUpdates,
+                            turnId: currentUserTurn.turnId,
+                        });
+                    }
+                };
                 const acceptActiveTurnInput = async (acceptanceInput) => {
                     const previousInput = currentInput;
-                    await persistInitialUserPromptToTranscriptIfNeeded({
-                        detail: 'user prompt persisted before active-turn input',
-                        prompt: previousInput.prompt,
-                        vault: previousInput.vault,
-                    });
+                    if (!holdGroupReplyDraft) {
+                        await persistInitialUserPromptToTranscriptIfNeeded({
+                            detail: 'user prompt persisted before active-turn input',
+                            prompt: previousInput.prompt,
+                            vault: previousInput.vault,
+                        });
+                    }
                     const acceptedInputItems = resolveAcceptedActiveTurnInputItems({
                         acceptedInput: acceptanceInput.activeTurnInput,
                         input: currentInput,
                     });
-                    assertAcceptedActiveTurnInputItemsAreNew({
-                        acceptedInputIds: acceptanceInput.providerRequestAcceptedInputIds,
-                        inputs: acceptedInputItems,
-                    });
-                    let acceptedInputJournal = await runtimeState.turns.acceptedInputs.append({
-                        inputs: acceptedInputItems,
-                        sessionId: resolved.session.sessionId,
-                        turnId: currentUserTurn.turnId,
-                    });
+                    const preProviderSteerJournalKey = JSON.stringify(acceptedInputItems.map((item) => item.id));
+                    const preProviderSteerJournal = preProviderSteerAcceptedInputJournals.get(preProviderSteerJournalKey);
+                    if (!preProviderSteerJournal) {
+                        assertAcceptedActiveTurnInputItemsAreNew({
+                            acceptedInputIds: acceptanceInput.providerRequestAcceptedInputIds,
+                            inputs: acceptedInputItems,
+                        });
+                    }
+                    const acceptedInputJournal = preProviderSteerJournal ??
+                        await runtimeState.turns.acceptedInputs.append({
+                            inputs: acceptedInputItems,
+                            sessionId: resolved.session.sessionId,
+                            turnId: currentUserTurn.turnId,
+                        });
+                    preProviderSteerAcceptedInputJournals.delete(preProviderSteerJournalKey);
                     await assertAssistantAcceptedTurnInputAssistantInputEventsExist({
                         journal: acceptedInputJournal,
                         vault: currentInput.vault,
                     });
-                    const transcriptRefsByInputId = await appendAcceptedActiveTurnInputTranscriptEntries({
-                        acceptedInput: acceptanceInput.activeTurnInput,
-                        acceptedInputItems,
-                        sessionId: resolved.session.sessionId,
-                        turnId: currentUserTurn.turnId,
-                        vault: currentInput.vault,
-                    });
-                    const transcriptRefUpdates = resolveAcceptedTurnInputTranscriptRefUpdates({
-                        inputs: acceptedInputItems,
-                        transcriptRefsByInputId,
-                    });
-                    if (transcriptRefUpdates.length > 0) {
-                        acceptedInputJournal =
-                            await runtimeState.turns.acceptedInputs.updateTranscriptRefs({
-                                refs: transcriptRefUpdates,
-                                turnId: currentUserTurn.turnId,
-                            }) ?? acceptedInputJournal;
+                    if (holdGroupReplyDraft) {
+                        heldGroupAcceptedTranscriptInputs.push({
+                            acceptedInput: acceptanceInput.activeTurnInput,
+                            acceptedInputItems,
+                        });
+                    }
+                    else {
+                        await persistAcceptedActiveTurnInputTranscripts({
+                            acceptedInput: acceptanceInput.activeTurnInput,
+                            acceptedInputItems,
+                        });
                     }
                     await appendAssistantTurnReceiptEvent({
                         vault: currentInput.vault,
@@ -659,7 +893,17 @@ export async function sendAssistantMessageLocal(input) {
                         acceptedInput: acceptanceInput.activeTurnInput,
                         input: previousInput,
                     });
-                    currentInput = nextInput;
+                    currentInput =
+                        holdGroupReplyDraft
+                            ? {
+                                ...nextInput,
+                                prompt: `${previousInput.prompt}\n\n${nextInput.prompt}`,
+                                userMessageContent: [
+                                    ...(previousInput.userMessageContent ?? []),
+                                    ...(acceptanceInput.activeTurnInput.userMessageContent ?? []),
+                                ],
+                            }
+                            : nextInput;
                     acceptedInputIdsForProviderRequest = acceptedInputJournal.inputIds;
                     acceptedInputItemsForProviderRequest = acceptedInputJournal.inputs;
                     return {
@@ -700,10 +944,12 @@ export async function sendAssistantMessageLocal(input) {
                     ];
                 }
                 const authorizeAcceptedMessageTarget = async (authorizationInput) => {
+                    const deliveryContextOrdinal = providerRequestDeliveryContextBaseOrdinal +
+                        authorizationInput.deliveryContextOrdinal;
                     const acceptedInputIds = authorizationInput.action === 'participant-effect'
-                        ? resolveAcceptedInputIdsThroughDeliveryContextOrdinal(authorizationInput.deliveryContextOrdinal)
-                        : acceptedInputIdsByDeliveryContextOrdinal[authorizationInput.deliveryContextOrdinal];
-                    const deliveryContext = replyDeliveryContexts[authorizationInput.deliveryContextOrdinal];
+                        ? resolveAcceptedInputIdsThroughDeliveryContextOrdinal(deliveryContextOrdinal)
+                        : acceptedInputIdsByDeliveryContextOrdinal[deliveryContextOrdinal];
+                    const deliveryContext = replyDeliveryContexts[deliveryContextOrdinal];
                     if (!acceptedInputIds || !deliveryContext) {
                         return null;
                     }
@@ -751,6 +997,7 @@ export async function sendAssistantMessageLocal(input) {
                 // effects may reference any input already admitted into the provider
                 // turn. Native replies and reactions remain exact to one ordinal.
                 const admissionMs = elapsedSince(admissionStartedAt);
+                const providerStartAtPreProviderSetupDone = stampAssistantProviderStartCriticalPath(providerStartAtTurnLockAcquired, 'preProviderSetupDoneAtMonotonicMs');
                 const preProviderSetupMs = elapsedSince(lockAcquiredAt);
                 emitHostedAssistantContextTimingTrace({
                     message: input,
@@ -773,154 +1020,459 @@ export async function sendAssistantMessageLocal(input) {
                         ...timingInput,
                     });
                 };
-                const drainLiveSteeredActiveTurnInputs = async (drainInput) => {
-                    while (true) {
-                        if (typeof drainInput.throughDeliveryContextOrdinal === 'number' &&
-                            replyDeliveryContexts.length > drainInput.throughDeliveryContextOrdinal) {
-                            break;
+                let liveSteeredActiveTurnInputDrainTail = Promise.resolve();
+                const drainLiveSteeredActiveTurnInputs = (drainInput) => {
+                    const drain = liveSteeredActiveTurnInputDrainTail.then(async () => {
+                        while (true) {
+                            if (typeof drainInput.throughDeliveryContextOrdinal === 'number' &&
+                                replyDeliveryContexts.length >
+                                    drainInput.throughDeliveryContextOrdinal) {
+                                break;
+                            }
+                            const activeTurnInput = await turnInputController.admitLiveSteered();
+                            if (activeTurnInput?.kind !== 'accepted') {
+                                break;
+                            }
+                            const accepted = await acceptActiveTurnInput({
+                                activeTurnInput,
+                                providerRequestAcceptedInputIds,
+                                providerRequestOrdinal,
+                                sessionId: drainInput.sessionId,
+                            });
+                            replyDeliveryContexts.push(pickAssistantReplyDeliveryContext(currentInput));
+                            acceptedInputIdsByDeliveryContextOrdinal[replyDeliveryContexts.length - 1] = accepted.acceptedInputItems.map((item) => item.id);
+                            if (drainInput.continuation) {
+                                providerRequestJournal =
+                                    await runtimeState.turns.acceptedInputs.updateProviderRequest({
+                                        acceptedInputIds: accepted.acceptedInputJournal.inputIds,
+                                        continuation: drainInput.continuation,
+                                        ordinal: providerRequestOrdinal,
+                                        providerAttemptId: null,
+                                        turnId: currentUserTurn.turnId,
+                                    }) ?? providerRequestJournal;
+                                providerRequestAcceptedInputIds =
+                                    providerRequestJournal?.inputIds ??
+                                        accepted.acceptedInputJournal.inputIds;
+                                providerRequestAcceptedInputItems =
+                                    providerRequestJournal?.inputs ??
+                                        accepted.acceptedInputJournal.inputs;
+                            }
+                            else {
+                                providerRequestAcceptedInputIds =
+                                    accepted.acceptedInputJournal.inputIds;
+                                providerRequestAcceptedInputItems =
+                                    accepted.acceptedInputJournal.inputs;
+                            }
+                            acceptedInputIdsForProviderRequest =
+                                providerRequestAcceptedInputIds;
+                            acceptedInputItemsForProviderRequest =
+                                providerRequestAcceptedInputItems;
+                            turnInputController.commitLiveSteeredLocalAdmission(activeTurnInput);
                         }
-                        const activeTurnInput = await turnInputController.admitLiveSteered();
-                        if (activeTurnInput?.kind !== 'accepted') {
-                            break;
+                    });
+                    liveSteeredActiveTurnInputDrainTail = drain.catch(() => undefined);
+                    return drain;
+                };
+                beforeHostedToolExecution = async (throughDeliveryContextOrdinal) => {
+                    await drainLiveSteeredActiveTurnInputs({
+                        continuation: providerRequestContinuation,
+                        sessionId: currentSession.sessionId,
+                        throughDeliveryContextOrdinal: providerRequestDeliveryContextBaseOrdinal +
+                            throughDeliveryContextOrdinal,
+                    });
+                };
+                const commitSelectedNoReply = async (selectedProviderResult) => {
+                    if (selectedProviderResult.finalAction?.kind !== 'none') {
+                        return;
+                    }
+                    await persistInitialUserPromptToTranscriptIfNeeded({
+                        detail: 'user prompt persisted before no-reply completion',
+                        prompt: currentInput.prompt,
+                        vault: currentInput.vault,
+                    });
+                    const deliveryContextOrdinal = selectedProviderResult.acceptedNoReplyDeliveryContextOrdinals?.at(-1)
+                        ?? selectedProviderResult.responseDeliveryContextOrdinal;
+                    await currentInput.onFinishWithoutReplyAccepted?.({
+                        acceptedInputIds: resolveAcceptedInputIdsThroughDeliveryContextOrdinal(deliveryContextOrdinal),
+                        deliveryContextOrdinal,
+                        messageReactionPending: (selectedProviderResult.reactions ?? []).some((reaction) => reaction.deliveryContextOrdinal <= deliveryContextOrdinal),
+                    });
+                };
+                const runCurrentProviderRequest = async (requestInput) => {
+                    providerRequestJournal = null;
+                    providerRequestContinuation = null;
+                    providerRequestAcceptedInputIds = acceptedInputIdsForProviderRequest;
+                    providerRequestAcceptedInputItems = acceptedInputItemsForProviderRequest;
+                    providerRequestStartedAtMs = null;
+                    providerResultReturnedAt = null;
+                    const onFirstAssistantResponseCompleted = () => {
+                        if (holdGroupReplyDraft && providerRequestOrdinal === 0) {
+                            turnInputController.pauseProviderSteering();
                         }
-                        const accepted = await acceptActiveTurnInput({
-                            activeTurnInput,
-                            providerRequestAcceptedInputIds,
-                            providerRequestOrdinal,
-                            sessionId: drainInput.sessionId,
-                        });
-                        replyDeliveryContexts.push(pickAssistantReplyDeliveryContext(currentInput));
-                        acceptedInputIdsByDeliveryContextOrdinal[replyDeliveryContexts.length - 1] = accepted.acceptedInputItems.map((item) => item.id);
-                        if (drainInput.continuation) {
+                        else {
+                            turnInputController.closeTurnAdmission();
+                        }
+                    };
+                    const activeTurnSteering = {
+                        onFirstAssistantResponseCompleted,
+                        registerLiveProviderTurn: (liveTurn) => turnInputController.registerLiveProviderTurn(liveTurn),
+                    };
+                    const providerOutcome = await executeCodexTurnWithRecovery({
+                        acceptedInputItems: providerRequestAcceptedInputItems,
+                        activeTurnSteering,
+                        authorizeAcceptedMessageTarget,
+                        input: currentInput,
+                        onFinishWithoutReplyAccepted: async (event) => {
+                            onFirstAssistantResponseCompleted();
+                            const deliveryContextOrdinal = providerRequestDeliveryContextBaseOrdinal +
+                                event.deliveryContextOrdinal;
+                            await drainLiveSteeredActiveTurnInputs({
+                                continuation: providerRequestContinuation,
+                                sessionId: currentSession.sessionId,
+                                throughDeliveryContextOrdinal: deliveryContextOrdinal,
+                            });
+                            if (!holdGroupReplyDraft) {
+                                await persistInitialUserPromptToTranscriptIfNeeded({
+                                    detail: 'user prompt persisted before no-reply completion',
+                                    prompt: currentInput.prompt,
+                                    vault: currentInput.vault,
+                                });
+                                const acceptedInputIds = resolveAcceptedInputIdsThroughDeliveryContextOrdinal(deliveryContextOrdinal);
+                                await currentInput.onFinishWithoutReplyAccepted?.({
+                                    acceptedInputIds,
+                                    deliveryContextOrdinal,
+                                    messageReactionPending: event.messageReactionPending,
+                                });
+                            }
+                        },
+                        onFinishWithoutReplyRecorded: async (event) => {
+                            if (!holdGroupReplyDraft) {
+                                await persistAssistantNoReplyTranscriptMarkers({
+                                    deliveryContextOrdinals: [
+                                        providerRequestDeliveryContextBaseOrdinal +
+                                            event.deliveryContextOrdinal,
+                                    ],
+                                    sessionId: currentSession.sessionId,
+                                    turnCreatedAt: currentUserTurn.turnCreatedAt,
+                                    turnId: currentUserTurn.turnId,
+                                    vault: input.vault,
+                                });
+                            }
+                        },
+                        onProviderRequestPlanned: async (event) => {
+                            providerRequestContinuation = event.codexContinuation;
                             providerRequestJournal =
-                                await runtimeState.turns.acceptedInputs.updateProviderRequest({
-                                    acceptedInputIds: accepted.acceptedInputJournal.inputIds,
-                                    continuation: drainInput.continuation,
+                                await runtimeState.turns.acceptedInputs.recordProviderRequest({
+                                    continuation: event.codexContinuation,
+                                    ordinal: providerRequestOrdinal,
+                                    providerAttemptId: event.providerAttemptId,
+                                    turnId: currentUserTurn.turnId,
+                                });
+                            providerRequestAcceptedInputIds =
+                                providerRequestJournal?.inputIds ?? acceptedInputIdsForProviderRequest;
+                            providerRequestAcceptedInputItems =
+                                providerRequestJournal?.inputs ?? acceptedInputItemsForProviderRequest;
+                            acceptedInputIdsForProviderRequest = providerRequestAcceptedInputIds;
+                            acceptedInputItemsForProviderRequest = providerRequestAcceptedInputItems;
+                            return await input.beforeProviderAcceptedInputs?.({
+                                acceptedInputs: providerRequestAcceptedInputItems,
+                                turnId: currentUserTurn.turnId,
+                            });
+                        },
+                        onProviderRequestStarted: (event) => {
+                            const startedAtMs = Date.parse(event.startedAt);
+                            if (Number.isFinite(startedAtMs)) {
+                                providerRequestStartedAtMs = startedAtMs;
+                            }
+                            if (!currentInput.onProviderRequestStarted) {
+                                return;
+                            }
+                            return currentInput.onProviderRequestStarted({
+                                ...event,
+                                acceptedInputIds: providerRequestAcceptedInputIds,
+                                admissionMs,
+                                preProviderSetupMs,
+                                promptBuildMs,
+                                providerRequestOrdinal: event.providerRequestOrdinal ?? providerRequestOrdinal,
+                                sessionResolveMs,
+                                turnLockWaitMs,
+                            });
+                        },
+                        route,
+                        plan: sharedPlan,
+                        profile: {
+                            threadScope,
+                        },
+                        providerRequestOrdinal,
+                        ...(providerStartAtPreProviderSetupDone
+                            ? {
+                                providerStartCriticalPath: providerStartAtPreProviderSetupDone,
+                            }
+                            : {}),
+                        resolvedSession: currentSession,
+                        turnCreatedAt: currentUserTurn.turnCreatedAt,
+                        progressDelivery,
+                        hostedToolContext,
+                        turnId: currentUserTurn.turnId,
+                    });
+                    providerResultReturnedAt = Date.now();
+                    emitTurnTiming({
+                        elapsedMs: elapsedSince(turnTimingStartedAt),
+                        providerOutcomeKind: providerOutcome.kind,
+                        providerRequestElapsedMs: providerRequestStartedAtMs === null
+                            ? null
+                            : Math.max(0, providerResultReturnedAt - providerRequestStartedAtMs),
+                        providerRequestOrdinal,
+                        sinceProviderResultMs: 0,
+                        stage: 'provider-result-returned',
+                    });
+                    if (providerOutcome.kind === 'failed_terminal') {
+                        if (!providerRequestJournal) {
+                            providerRequestJournal =
+                                await runtimeState.turns.acceptedInputs.recordProviderRequest({
+                                    continuation: providerOutcome.codexContinuation,
                                     ordinal: providerRequestOrdinal,
                                     providerAttemptId: null,
                                     turnId: currentUserTurn.turnId,
-                                }) ?? providerRequestJournal;
+                                });
                             providerRequestAcceptedInputIds =
-                                providerRequestJournal?.inputIds ??
-                                    accepted.acceptedInputJournal.inputIds;
+                                providerRequestJournal?.inputIds ?? acceptedInputIdsForProviderRequest;
                             providerRequestAcceptedInputItems =
-                                providerRequestJournal?.inputs ??
-                                    accepted.acceptedInputJournal.inputs;
+                                providerRequestJournal?.inputs ?? acceptedInputItemsForProviderRequest;
+                            acceptedInputIdsForProviderRequest = providerRequestAcceptedInputIds;
+                            acceptedInputItemsForProviderRequest = providerRequestAcceptedInputItems;
                         }
                         else {
+                            providerRequestJournal =
+                                await runtimeState.turns.acceptedInputs.updateProviderRequest({
+                                    continuation: providerOutcome.codexContinuation,
+                                    ordinal: providerRequestOrdinal,
+                                    providerAttemptId: null,
+                                    turnId: currentUserTurn.turnId,
+                                }) ?? providerRequestJournal;
                             providerRequestAcceptedInputIds =
-                                accepted.acceptedInputJournal.inputIds;
+                                providerRequestJournal?.inputIds ?? providerRequestAcceptedInputIds;
                             providerRequestAcceptedInputItems =
-                                accepted.acceptedInputJournal.inputs;
+                                providerRequestJournal?.inputs ?? providerRequestAcceptedInputItems;
+                            acceptedInputIdsForProviderRequest = providerRequestAcceptedInputIds;
+                            acceptedInputItemsForProviderRequest = providerRequestAcceptedInputItems;
                         }
-                        acceptedInputIdsForProviderRequest = providerRequestAcceptedInputIds;
-                        acceptedInputItemsForProviderRequest = providerRequestAcceptedInputItems;
-                    }
-                };
-                beforeHostedToolExecution = async () => {
-                    await drainLiveSteeredActiveTurnInputs({
-                        continuation: providerRequestContinuation,
-                        sessionId: currentSession.sessionId,
-                    });
-                };
-                const providerOutcome = await executeCodexTurnWithRecovery({
-                    acceptedInputItems: providerRequestAcceptedInputItems,
-                    activeTurnSteering: turnInputController,
-                    authorizeAcceptedMessageTarget,
-                    input: currentInput,
-                    onFinishWithoutReplyAccepted: async (event) => {
-                        await drainLiveSteeredActiveTurnInputs({
-                            continuation: providerRequestContinuation,
-                            sessionId: currentSession.sessionId,
-                            throughDeliveryContextOrdinal: event.deliveryContextOrdinal,
-                        });
-                        await persistInitialUserPromptToTranscriptIfNeeded({
-                            detail: 'user prompt persisted before no-reply completion',
-                            prompt: currentInput.prompt,
-                            vault: currentInput.vault,
+                        const failedProviderResult = {
+                            attemptCount: providerOutcome.attemptCount,
+                            provider: providerOutcome.route.provider,
+                            providerOptions: providerOutcome.route.providerOptions,
+                            route: providerOutcome.route,
+                            session: providerOutcome.session,
+                            usage: providerOutcome.usage,
+                            usageAttribution: providerOutcome.usageAttribution,
+                        };
+                        const acceptedNoReplyOrdinals = providerOutcome.acceptedNoReplyDeliveryContextOrdinals ?? [];
+                        const latestAcceptedDeliveryContextOrdinal = replyDeliveryContexts.length - 1;
+                        const recoverableNoReplyDeliveryContextOrdinal = latestAcceptedDeliveryContextOrdinal >= 0 &&
+                            acceptedNoReplyOrdinals.includes(latestAcceptedDeliveryContextOrdinal)
+                            ? latestAcceptedDeliveryContextOrdinal
+                            : null;
+                        if (recoverableNoReplyDeliveryContextOrdinal === null ||
+                            !requestInput.allowFailedNoReplyRecovery) {
+                            await drainLiveSteeredActiveTurnInputs({
+                                continuation: providerOutcome.codexContinuation,
+                                sessionId: providerOutcome.session.sessionId,
+                            });
+                        }
+                        const usageRecordStartedAt = Date.now();
+                        const primaryUsageRecordOrdinal = nextUsageRecordOrdinal;
+                        nextUsageRecordOrdinal += 1;
+                        await recordAssistantUsageEvent({
+                            executionContext,
+                            ...(providerRequestStartedAtMs === null
+                                ? {}
+                                : { occurredAt: new Date(providerRequestStartedAtMs).toISOString() }),
+                            providerRequestAcceptedInputIds,
+                            providerRequestOrdinal: primaryUsageRecordOrdinal,
+                            providerRequestOutcome: providerOutcome.providerRequestOutcome,
+                            providerResult: failedProviderResult,
+                            turnId: currentUserTurn.turnId,
                         });
-                        const acceptedInputIds = resolveAcceptedInputIdsThroughDeliveryContextOrdinal(event.deliveryContextOrdinal);
-                        await currentInput.onFinishWithoutReplyAccepted?.({
-                            acceptedInputIds,
-                            deliveryContextOrdinal: event.deliveryContextOrdinal,
-                            messageReactionPending: event.messageReactionPending,
+                        emitTurnTiming({
+                            elapsedMs: elapsedSince(turnTimingStartedAt),
+                            providerRequestOrdinal,
+                            sinceProviderResultMs: providerResultReturnedAt === null
+                                ? null
+                                : elapsedSince(providerResultReturnedAt),
+                            stage: 'usage-recorded',
+                            stepElapsedMs: elapsedSince(usageRecordStartedAt),
                         });
-                    },
-                    onFinishWithoutReplyRecorded: async (event) => {
-                        await persistAssistantNoReplyTranscriptMarkers({
-                            deliveryContextOrdinals: [event.deliveryContextOrdinal],
-                            sessionId: currentSession.sessionId,
-                            turnCreatedAt: currentUserTurn.turnCreatedAt,
+                        const additionalUsages = providerOutcome.additionalUsages?.map((usageDraft) => ({
+                            ...usageDraft,
+                            providerRequestOrdinal: nextUsageRecordOrdinal++,
+                        }));
+                        await recordAdditionalAssistantUsageEvents({
+                            additionalUsages,
+                            effectiveEnv: currentInput.turnEnvironment?.env ?? process.env,
+                            executionContext,
+                            providerRequestAcceptedInputIds,
+                            providerResult: failedProviderResult,
                             turnId: currentUserTurn.turnId,
+                        });
+                        const failedProviderResumeStateAction = providerRequestOrdinal === 1
+                            ? 'preserve-existing'
+                            : resolveAssistantProviderResumeStateAction({
+                                codexThreadId: providerOutcome.codexThreadId ?? null,
+                                threadScope,
+                            });
+                        if (progressDeliveredSessionRef.value) {
+                            currentSession = applyAssistantProgressDeliveredSession({
+                                progressDeliveredSession: progressDeliveredSessionRef.value,
+                                session: providerOutcome.session,
+                            });
+                        }
+                        currentSession = await applyAssistantSessionCodexResumeStateAction({
+                            action: failedProviderResumeStateAction,
+                            assistantContractFingerprint: providerOutcome.assistantContractFingerprint,
+                            codexRolloutRelativePath: providerOutcome.codexRolloutRelativePath,
+                            codexThreadId: providerOutcome.codexThreadId,
+                            routeFingerprint: readCodexThreadRouteFingerprint(providerOutcome.route),
+                            threadCompatibilityFingerprint: readCodexThreadCompatibilityFingerprint(providerOutcome.route),
+                            session: currentSession,
                             vault: input.vault,
                         });
-                    },
-                    onProviderRequestPlanned: async (event) => {
-                        providerRequestContinuation = event.codexContinuation;
-                        providerRequestJournal =
-                            await runtimeState.turns.acceptedInputs.recordProviderRequest({
-                                continuation: event.codexContinuation,
-                                ordinal: providerRequestOrdinal,
-                                providerAttemptId: event.providerAttemptId,
+                        if (requestInput.allowFailedNoReplyRecovery &&
+                            recoverableNoReplyDeliveryContextOrdinal !== null) {
+                            turnInputController.close();
+                            await runtimeState.turns.acceptedInputs.updateAdmissionState({
+                                admissionState: 'commit-started',
                                 turnId: currentUserTurn.turnId,
                             });
-                        providerRequestAcceptedInputIds =
-                            providerRequestJournal?.inputIds ?? acceptedInputIdsForProviderRequest;
-                        providerRequestAcceptedInputItems =
-                            providerRequestJournal?.inputs ?? acceptedInputItemsForProviderRequest;
-                        acceptedInputIdsForProviderRequest = providerRequestAcceptedInputIds;
-                        acceptedInputItemsForProviderRequest = providerRequestAcceptedInputItems;
-                        return await input.beforeProviderAcceptedInputs?.({
-                            acceptedInputs: providerRequestAcceptedInputItems,
-                        });
-                    },
-                    onProviderRequestStarted: (event) => {
-                        const startedAtMs = Date.parse(event.startedAt);
-                        if (Number.isFinite(startedAtMs)) {
-                            providerRequestStartedAtMs = startedAtMs;
-                        }
-                        if (!currentInput.onProviderRequestStarted) {
-                            return;
+                            const recoveredReactions = (providerOutcome.reactions ?? []).filter((reaction) => reaction.deliveryContextOrdinal <= recoverableNoReplyDeliveryContextOrdinal);
+                            const failedNoReplySession = currentSession;
+                            const failedNoReplyProviderResult = {
+                                acceptedNoReplyDeliveryContextOrdinals: acceptedNoReplyOrdinals,
+                                assistantContractFingerprint: providerOutcome.assistantContractFingerprint,
+                                attemptCount: providerOutcome.attemptCount,
+                                codexContinuation: providerOutcome.codexContinuation,
+                                codexRolloutRelativePath: providerOutcome.codexRolloutRelativePath,
+                                codexThreadId: providerOutcome.codexThreadId,
+                                finalAction: {
+                                    kind: 'none',
+                                },
+                                provider: providerOutcome.route.provider,
+                                providerOptions: providerOutcome.route.providerOptions,
+                                rawEvents: providerOutcome.rawEvents,
+                                reactions: recoveredReactions,
+                                response: '',
+                                responseDeliveryContextOrdinal: recoverableNoReplyDeliveryContextOrdinal,
+                                responseMedia: [],
+                                responseCard: null,
+                                route: providerOutcome.route,
+                                session: failedNoReplySession,
+                                stderr: '',
+                                stdout: '',
+                                transcriptResponse: null,
+                                usage: providerOutcome.usage,
+                                usageAttribution: providerOutcome.usageAttribution,
+                                workingDirectory: sharedPlan.requestedWorkingDirectory,
+                            };
+                            const turnArtifactsStartedAt = Date.now();
+                            const session = await finalizeAssistantTurnArtifacts({
+                                assistantTranscriptText: null,
+                                input: currentInput,
+                                plan: sharedPlan,
+                                precedingAssistantTranscriptTexts: [],
+                                providerResult: failedNoReplyProviderResult,
+                                providerResumeStateAction: failedProviderResumeStateAction,
+                                persistUserPromptToTranscript: !userPromptPersistedToTranscript,
+                                session: failedNoReplySession,
+                                turnCreatedAt: currentUserTurn.turnCreatedAt,
+                                turnId: currentUserTurn.turnId,
+                                userContentReceivedAt: currentUserTurn.userContentReceivedAt,
+                            });
+                            currentSession = session;
+                            emitTurnTiming({
+                                elapsedMs: elapsedSince(turnTimingStartedAt),
+                                finalReplySelected: false,
+                                providerRequestOrdinal,
+                                sinceProviderResultMs: providerResultReturnedAt === null
+                                    ? null
+                                    : elapsedSince(providerResultReturnedAt),
+                                stage: 'turn-artifacts-finalized',
+                                stepElapsedMs: elapsedSince(turnArtifactsStartedAt),
+                            });
+                            const replyDispatchStartedAt = Date.now();
+                            const { deliverySession, reactionDeliveryOutcomes, } = await deliverAssistantProviderReactions({
+                                acceptedInputIdsByDeliveryContextOrdinal,
+                                currentInput,
+                                providerResult: failedNoReplyProviderResult,
+                                replyDeliveryContexts,
+                                session,
+                                sharedPlan,
+                                turnId: currentUserTurn.turnId,
+                            });
+                            const deliveryOutcome = resolveAssistantNoReplyDeliveryOutcome({
+                                precedingDeliveryOutcomes: [],
+                                session: deliverySession,
+                            });
+                            const finalDeliveryOutcome = deliveryOutcome.kind === 'not-requested' &&
+                                reactionDeliveryOutcomes.length > 0
+                                ? reactionDeliveryOutcomes[reactionDeliveryOutcomes.length - 1]
+                                : deliveryOutcome;
+                            emitTurnTiming({
+                                deliveryAttempted: reactionDeliveryOutcomes.length > 0,
+                                deliveryIntentPresent: 'intentId' in finalDeliveryOutcome
+                                    ? finalDeliveryOutcome.intentId !== null
+                                    : false,
+                                deliveryOutcomeKind: finalDeliveryOutcome.kind,
+                                elapsedMs: elapsedSince(turnTimingStartedAt),
+                                finalReplySelected: false,
+                                providerRequestOrdinal,
+                                sinceProviderResultMs: providerResultReturnedAt === null
+                                    ? null
+                                    : elapsedSince(providerResultReturnedAt),
+                                stage: 'reply-dispatched',
+                                stepElapsedMs: elapsedSince(replyDispatchStartedAt),
+                            });
+                            await finalizeDeliveredAssistantTurn({
+                                firstContactStateDocIds: sharedPlan.firstContactStateDocIds,
+                                outcome: finalDeliveryOutcome,
+                                response: '',
+                                turnId: currentUserTurn.turnId,
+                                vault: input.vault,
+                            });
+                            const result = normalizeAssistantAskResultForReturn({
+                                vault: redactAssistantDisplayPath(input.vault),
+                                status: 'completed',
+                                prompt: currentInput.prompt,
+                                response: '',
+                                responseDisposition: 'none',
+                                media: finalDeliveryOutcome.media,
+                                session: finalDeliveryOutcome.session,
+                                delivery: finalDeliveryOutcome.kind === 'sent'
+                                    ? finalDeliveryOutcome.delivery
+                                    : null,
+                                deliveryDeferred: finalDeliveryOutcome.kind === 'queued',
+                                deliveryIntentId: finalDeliveryOutcome.kind === 'sent' ||
+                                    finalDeliveryOutcome.kind === 'queued' ||
+                                    finalDeliveryOutcome.kind === 'failed'
+                                    ? finalDeliveryOutcome.intentId
+                                    : null,
+                                deliveryError: finalDeliveryOutcome.kind === 'queued' ||
+                                    finalDeliveryOutcome.kind === 'failed'
+                                    ? finalDeliveryOutcome.error
+                                    : null,
+                            });
+                            turnInputController.complete(result);
+                            return {
+                                kind: 'completed',
+                                result,
+                            };
                         }
-                        return currentInput.onProviderRequestStarted({
-                            ...event,
-                            acceptedInputIds: providerRequestAcceptedInputIds,
-                            admissionMs,
-                            preProviderSetupMs,
-                            promptBuildMs,
-                            providerRequestOrdinal: event.providerRequestOrdinal ?? providerRequestOrdinal,
-                            sessionResolveMs,
-                            turnLockWaitMs,
-                        });
-                    },
-                    route,
-                    plan: sharedPlan,
-                    profile: {
-                        threadScope,
-                    },
-                    providerRequestOrdinal,
-                    resolvedSession: currentSession,
-                    turnCreatedAt: currentUserTurn.turnCreatedAt,
-                    progressDelivery,
-                    hostedToolContext,
-                    turnId: currentUserTurn.turnId,
-                });
-                providerResultReturnedAt = Date.now();
-                emitTurnTiming({
-                    elapsedMs: elapsedSince(turnTimingStartedAt),
-                    providerOutcomeKind: providerOutcome.kind,
-                    providerRequestElapsedMs: providerRequestStartedAtMs === null
-                        ? null
-                        : Math.max(0, providerResultReturnedAt - providerRequestStartedAtMs),
-                    providerRequestOrdinal,
-                    sinceProviderResultMs: 0,
-                    stage: 'provider-result-returned',
-                });
-                if (providerOutcome.kind === 'failed_terminal') {
+                        throw providerOutcome.error;
+                    }
+                    onFirstAssistantResponseCompleted();
+                    const currentProviderResult = providerOutcome.providerTurn;
                     if (!providerRequestJournal) {
                         providerRequestJournal =
                             await runtimeState.turns.acceptedInputs.recordProviderRequest({
-                                continuation: providerOutcome.codexContinuation,
+                                continuation: currentProviderResult.codexContinuation,
                                 ordinal: providerRequestOrdinal,
                                 providerAttemptId: null,
                                 turnId: currentUserTurn.turnId,
@@ -935,7 +1487,7 @@ export async function sendAssistantMessageLocal(input) {
                     else {
                         providerRequestJournal =
                             await runtimeState.turns.acceptedInputs.updateProviderRequest({
-                                continuation: providerOutcome.codexContinuation,
+                                continuation: currentProviderResult.codexContinuation,
                                 ordinal: providerRequestOrdinal,
                                 providerAttemptId: null,
                                 turnId: currentUserTurn.turnId,
@@ -947,34 +1499,35 @@ export async function sendAssistantMessageLocal(input) {
                         acceptedInputIdsForProviderRequest = providerRequestAcceptedInputIds;
                         acceptedInputItemsForProviderRequest = providerRequestAcceptedInputItems;
                     }
-                    const failedProviderResult = {
-                        attemptCount: providerOutcome.attemptCount,
-                        provider: providerOutcome.route.provider,
-                        providerOptions: providerOutcome.route.providerOptions,
-                        route: providerOutcome.route,
-                        session: providerOutcome.session,
-                        usage: providerOutcome.usage,
-                        usageAttribution: providerOutcome.usageAttribution,
-                    };
-                    const acceptedNoReplyOrdinals = providerOutcome.acceptedNoReplyDeliveryContextOrdinals ?? [];
-                    const latestAcceptedDeliveryContextOrdinal = replyDeliveryContexts.length - 1;
-                    const recoverableNoReplyDeliveryContextOrdinal = latestAcceptedDeliveryContextOrdinal >= 0 &&
-                        acceptedNoReplyOrdinals.includes(latestAcceptedDeliveryContextOrdinal)
-                        ? latestAcceptedDeliveryContextOrdinal
-                        : null;
-                    if (recoverableNoReplyDeliveryContextOrdinal === null) {
-                        await drainLiveSteeredActiveTurnInputs({
-                            continuation: providerOutcome.codexContinuation,
-                            sessionId: providerOutcome.session.sessionId,
+                    await drainLiveSteeredActiveTurnInputs({
+                        continuation: currentProviderResult.codexContinuation,
+                        sessionId: currentProviderResult.session.sessionId,
+                        throughDeliveryContextOrdinal: providerRequestDeliveryContextBaseOrdinal +
+                            currentProviderResult.responseDeliveryContextOrdinal,
+                    });
+                    currentSession = applyAssistantProgressDeliveredSession({
+                        progressDeliveredSession: progressDeliveredSessionRef.value,
+                        session: currentProviderResult.session,
+                    });
+                    if (!holdGroupReplyDraft) {
+                        responseText = resolveAssistantPersistedReplyText({
+                            messageInput: currentInput,
+                            rawResponse: currentProviderResult.response,
+                            session: currentSession,
+                            sharedPlan,
                         });
                     }
                     const usageRecordStartedAt = Date.now();
+                    const primaryUsageRecordOrdinal = nextUsageRecordOrdinal;
+                    nextUsageRecordOrdinal += 1;
                     await recordAssistantUsageEvent({
                         executionContext,
+                        ...(providerRequestStartedAtMs === null
+                            ? {}
+                            : { occurredAt: new Date(providerRequestStartedAtMs).toISOString() }),
                         providerRequestAcceptedInputIds,
-                        providerRequestOrdinal,
-                        providerRequestOutcome: providerOutcome.providerRequestOutcome,
-                        providerResult: failedProviderResult,
+                        providerRequestOrdinal: primaryUsageRecordOrdinal,
+                        providerResult: currentProviderResult,
                         turnId: currentUserTurn.turnId,
                     });
                     emitTurnTiming({
@@ -986,230 +1539,90 @@ export async function sendAssistantMessageLocal(input) {
                         stage: 'usage-recorded',
                         stepElapsedMs: elapsedSince(usageRecordStartedAt),
                     });
+                    const additionalUsages = currentProviderResult.additionalUsages?.map((usageDraft) => ({
+                        ...usageDraft,
+                        providerRequestOrdinal: nextUsageRecordOrdinal++,
+                    }));
                     await recordAdditionalAssistantUsageEvents({
-                        additionalUsages: providerOutcome.additionalUsages,
+                        additionalUsages,
                         effectiveEnv: currentInput.turnEnvironment?.env ?? process.env,
                         executionContext,
                         providerRequestAcceptedInputIds,
-                        providerResult: failedProviderResult,
+                        providerResult: currentProviderResult,
                         turnId: currentUserTurn.turnId,
                     });
-                    const failedProviderResumeStateAction = resolveAssistantProviderResumeStateAction({
-                        codexThreadId: providerOutcome.codexThreadId ?? null,
-                        threadScope,
-                    });
-                    if (progressDeliveredSessionRef.value) {
-                        currentSession = applyAssistantProgressDeliveredSession({
-                            progressDeliveredSession: progressDeliveredSessionRef.value,
-                            session: providerOutcome.session,
-                        });
-                    }
-                    currentSession = await applyAssistantSessionCodexResumeStateAction({
-                        action: failedProviderResumeStateAction,
-                        assistantContractFingerprint: providerOutcome.assistantContractFingerprint,
-                        codexRolloutRelativePath: providerOutcome.codexRolloutRelativePath,
-                        codexThreadId: providerOutcome.codexThreadId,
-                        routeFingerprint: readCodexThreadRouteFingerprint(providerOutcome.route),
-                        threadCompatibilityFingerprint: readCodexThreadCompatibilityFingerprint(providerOutcome.route),
-                        session: currentSession,
-                        vault: input.vault,
+                    return {
+                        kind: 'provider-result',
+                        providerResult: rebaseAssistantProviderResultDeliveryContexts({
+                            baseOrdinal: providerRequestDeliveryContextBaseOrdinal,
+                            providerResult: currentProviderResult,
+                        }),
+                    };
+                };
+                const firstRequest = await runCurrentProviderRequest({
+                    allowFailedNoReplyRecovery: !holdGroupReplyDraft,
+                });
+                if (firstRequest.kind === 'completed') {
+                    return firstRequest.result;
+                }
+                providerResult = firstRequest.providerResult;
+                if (holdGroupReplyDraft) {
+                    const draftWindowOutcome = await turnInputController.finishDraftWindow({
+                        signal: currentInput.abortSignal,
                     });
-                    if (recoverableNoReplyDeliveryContextOrdinal !== null) {
-                        turnInputController.close();
-                        await runtimeState.turns.acceptedInputs.updateAdmissionState({
-                            admissionState: 'commit-started',
-                            turnId: currentUserTurn.turnId,
-                        });
-                        const recoveredReactions = (providerOutcome.reactions ?? []).filter((reaction) => reaction.deliveryContextOrdinal <= recoverableNoReplyDeliveryContextOrdinal);
-                        const failedNoReplySession = currentSession;
-                        const failedNoReplyProviderResult = {
-                            acceptedNoReplyDeliveryContextOrdinals: acceptedNoReplyOrdinals,
-                            assistantContractFingerprint: providerOutcome.assistantContractFingerprint,
-                            attemptCount: providerOutcome.attemptCount,
-                            codexContinuation: providerOutcome.codexContinuation,
-                            codexRolloutRelativePath: providerOutcome.codexRolloutRelativePath,
-                            codexThreadId: providerOutcome.codexThreadId,
-                            finalAction: {
-                                kind: 'none',
-                            },
-                            provider: providerOutcome.route.provider,
-                            providerOptions: providerOutcome.route.providerOptions,
-                            rawEvents: providerOutcome.rawEvents,
-                            reactions: recoveredReactions,
-                            response: '',
-                            responseDeliveryContextOrdinal: recoverableNoReplyDeliveryContextOrdinal,
-                            responseMedia: [],
-                            route: providerOutcome.route,
-                            session: failedNoReplySession,
-                            stderr: '',
-                            stdout: '',
-                            transcriptResponse: null,
-                            usage: providerOutcome.usage,
-                            usageAttribution: providerOutcome.usageAttribution,
-                            workingDirectory: sharedPlan.requestedWorkingDirectory,
-                        };
-                        const turnArtifactsStartedAt = Date.now();
-                        const session = await finalizeAssistantTurnArtifacts({
-                            assistantTranscriptText: null,
-                            input: currentInput,
-                            plan: sharedPlan,
-                            precedingAssistantTranscriptTexts: [],
-                            providerResult: failedNoReplyProviderResult,
-                            providerResumeStateAction: failedProviderResumeStateAction,
-                            persistUserPromptToTranscript: !userPromptPersistedToTranscript,
-                            session: failedNoReplySession,
-                            turnCreatedAt: currentUserTurn.turnCreatedAt,
-                            turnId: currentUserTurn.turnId,
-                            userContentReceivedAt: currentUserTurn.userContentReceivedAt,
-                        });
-                        currentSession = session;
-                        emitTurnTiming({
-                            elapsedMs: elapsedSince(turnTimingStartedAt),
-                            finalReplySelected: false,
-                            providerRequestOrdinal,
-                            sinceProviderResultMs: providerResultReturnedAt === null
-                                ? null
-                                : elapsedSince(providerResultReturnedAt),
-                            stage: 'turn-artifacts-finalized',
-                            stepElapsedMs: elapsedSince(turnArtifactsStartedAt),
-                        });
-                        const replyDispatchStartedAt = Date.now();
-                        const { deliverySession, reactionDeliveryOutcomes, } = await deliverAssistantProviderReactions({
-                            acceptedInputIdsByDeliveryContextOrdinal,
-                            currentInput,
-                            providerResult: failedNoReplyProviderResult,
-                            replyDeliveryContexts,
-                            session,
-                            sharedPlan,
-                            turnId: currentUserTurn.turnId,
-                        });
-                        const deliveryOutcome = resolveAssistantNoReplyDeliveryOutcome({
-                            precedingDeliveryOutcomes: [],
-                            session: deliverySession,
-                        });
-                        const finalDeliveryOutcome = deliveryOutcome.kind === 'not-requested' &&
-                            reactionDeliveryOutcomes.length > 0
-                            ? reactionDeliveryOutcomes[reactionDeliveryOutcomes.length - 1]
-                            : deliveryOutcome;
-                        emitTurnTiming({
-                            deliveryAttempted: reactionDeliveryOutcomes.length > 0,
-                            deliveryIntentPresent: 'intentId' in finalDeliveryOutcome
-                                ? finalDeliveryOutcome.intentId !== null
-                                : false,
-                            deliveryOutcomeKind: finalDeliveryOutcome.kind,
-                            elapsedMs: elapsedSince(turnTimingStartedAt),
-                            finalReplySelected: false,
-                            providerRequestOrdinal,
-                            sinceProviderResultMs: providerResultReturnedAt === null
-                                ? null
-                                : elapsedSince(providerResultReturnedAt),
-                            stage: 'reply-dispatched',
-                            stepElapsedMs: elapsedSince(replyDispatchStartedAt),
-                        });
-                        await finalizeDeliveredAssistantTurn({
-                            firstContactStateDocIds: sharedPlan.firstContactStateDocIds,
-                            outcome: finalDeliveryOutcome,
-                            response: '',
-                            turnId: currentUserTurn.turnId,
-                            vault: input.vault,
-                        });
-                        const result = normalizeAssistantAskResultForReturn({
-                            vault: redactAssistantDisplayPath(input.vault),
-                            status: 'completed',
-                            prompt: currentInput.prompt,
-                            response: '',
-                            responseDisposition: 'none',
-                            media: finalDeliveryOutcome.media,
-                            session: finalDeliveryOutcome.session,
-                            delivery: finalDeliveryOutcome.kind === 'sent'
-                                ? finalDeliveryOutcome.delivery
-                                : null,
-                            deliveryDeferred: finalDeliveryOutcome.kind === 'queued',
-                            deliveryIntentId: finalDeliveryOutcome.kind === 'sent' ||
-                                finalDeliveryOutcome.kind === 'queued' ||
-                                finalDeliveryOutcome.kind === 'failed'
-                                ? finalDeliveryOutcome.intentId
-                                : null,
-                            deliveryError: finalDeliveryOutcome.kind === 'queued' ||
-                                finalDeliveryOutcome.kind === 'failed'
-                                ? finalDeliveryOutcome.error
-                                : null,
-                        });
-                        turnInputController.complete(result);
-                        return result;
+                    if (draftWindowOutcome.kind === 'review') {
+                        providerRequestOrdinal = 1;
+                        try {
+                            if (draftWindowOutcome.acceptedInput) {
+                                const accepted = await acceptActiveTurnInput({
+                                    activeTurnInput: draftWindowOutcome.acceptedInput,
+                                    providerRequestAcceptedInputIds,
+                                    providerRequestOrdinal,
+                                    sessionId: currentSession.sessionId,
+                                });
+                                replyDeliveryContexts.push(pickAssistantReplyDeliveryContext(currentInput));
+                                acceptedInputIdsByDeliveryContextOrdinal[replyDeliveryContexts.length - 1] = accepted.acceptedInputItems.map((item) => item.id);
+                            }
+                            providerRequestDeliveryContextBaseOrdinal =
+                                replyDeliveryContexts.length - 1;
+                            currentSession = applyAssistantProviderTurnResumeInMemory({
+                                providerResult,
+                                session: currentSession,
+                            });
+                            currentInput = {
+                                ...currentInput,
+                                turnContext: appendAssistantTurnContext(currentInput.turnContext, ASSISTANT_GROUP_REPLY_RECONSIDERATION_INSTRUCTION),
+                            };
+                            const reconsiderationRequest = await runCurrentProviderRequest({
+                                allowFailedNoReplyRecovery: false,
+                            });
+                            if (reconsiderationRequest.kind === 'completed') {
+                                throw new VaultCliError('ASSISTANT_GROUP_DRAFT_RECONSIDERATION_INVALID_RECOVERY', 'The group reply reconsideration unexpectedly completed through provider failure recovery.');
+                            }
+                            providerResult = reconsiderationRequest.providerResult;
+                        }
+                        finally {
+                            currentSession = {
+                                ...currentSession,
+                                codexResume: null,
+                                resumeState: null,
+                            };
+                            await runAssistantTurnBestEffort(async () => {
+                                currentSession = await clearAssistantSessionCodexResumeState({
+                                    session: currentSession,
+                                    vault: input.vault,
+                                });
+                            });
+                        }
                     }
-                    throw providerOutcome.error;
-                }
-                providerResult = providerOutcome.providerTurn;
-                if (!providerRequestJournal) {
-                    providerRequestJournal =
-                        await runtimeState.turns.acceptedInputs.recordProviderRequest({
-                            continuation: providerResult.codexContinuation,
-                            ordinal: providerRequestOrdinal,
-                            providerAttemptId: null,
-                            turnId: currentUserTurn.turnId,
-                        });
-                    providerRequestAcceptedInputIds =
-                        providerRequestJournal?.inputIds ?? acceptedInputIdsForProviderRequest;
-                    providerRequestAcceptedInputItems =
-                        providerRequestJournal?.inputs ?? acceptedInputItemsForProviderRequest;
-                    acceptedInputIdsForProviderRequest = providerRequestAcceptedInputIds;
-                    acceptedInputItemsForProviderRequest = providerRequestAcceptedInputItems;
-                }
-                else {
-                    providerRequestJournal =
-                        await runtimeState.turns.acceptedInputs.updateProviderRequest({
-                            continuation: providerResult.codexContinuation,
-                            ordinal: providerRequestOrdinal,
-                            providerAttemptId: null,
-                            turnId: currentUserTurn.turnId,
-                        }) ?? providerRequestJournal;
-                    providerRequestAcceptedInputIds =
-                        providerRequestJournal?.inputIds ?? providerRequestAcceptedInputIds;
-                    providerRequestAcceptedInputItems =
-                        providerRequestJournal?.inputs ?? providerRequestAcceptedInputItems;
-                    acceptedInputIdsForProviderRequest = providerRequestAcceptedInputIds;
-                    acceptedInputItemsForProviderRequest = providerRequestAcceptedInputItems;
+                    providerResult = selectAssistantGroupProviderResult(providerResult);
                 }
-                await drainLiveSteeredActiveTurnInputs({
-                    continuation: providerResult.codexContinuation,
-                    sessionId: providerResult.session.sessionId,
-                });
-                currentSession = applyAssistantProgressDeliveredSession({
-                    progressDeliveredSession: progressDeliveredSessionRef.value,
-                    session: providerResult.session,
-                });
                 responseText = resolveAssistantPersistedReplyText({
                     messageInput: currentInput,
                     rawResponse: providerResult.response,
                     session: currentSession,
                     sharedPlan,
                 });
-                const usageRecordStartedAt = Date.now();
-                await recordAssistantUsageEvent({
-                    executionContext,
-                    providerRequestAcceptedInputIds,
-                    providerRequestOrdinal,
-                    providerResult,
-                    turnId: currentUserTurn.turnId,
-                });
-                emitTurnTiming({
-                    elapsedMs: elapsedSince(turnTimingStartedAt),
-                    providerRequestOrdinal,
-                    sinceProviderResultMs: providerResultReturnedAt === null
-                        ? null
-                        : elapsedSince(providerResultReturnedAt),
-                    stage: 'usage-recorded',
-                    stepElapsedMs: elapsedSince(usageRecordStartedAt),
-                });
-                await recordAdditionalAssistantUsageEvents({
-                    additionalUsages: providerResult.additionalUsages,
-                    effectiveEnv: currentInput.turnEnvironment?.env ?? process.env,
-                    executionContext,
-                    providerRequestAcceptedInputIds,
-                    providerResult,
-                    turnId: currentUserTurn.turnId,
-                });
                 const resolvedFinalReplyDeliveryContext = resolveAssistantReplyDeliveryContextForSegment({
                     contexts: replyDeliveryContexts,
                     deliveryContextOrdinal: providerResult.responseDeliveryContextOrdinal,
@@ -1229,9 +1642,17 @@ export async function sendAssistantMessageLocal(input) {
                     admissionState: 'commit-started',
                     turnId: currentUserTurn.turnId,
                 });
-                // Every completed provider response is part of the ordinary turn,
-                // regardless of audience. A later steer may add another response, but
-                // it never erases text or media the provider already completed.
+                if (holdGroupReplyDraft) {
+                    await persistInitialUserPromptToTranscriptIfNeeded({
+                        detail: 'user prompt persisted after held group reply selection',
+                        prompt: input.prompt,
+                        vault: input.vault,
+                    });
+                    for (const heldInput of heldGroupAcceptedTranscriptInputs) {
+                        await persistAcceptedActiveTurnInputTranscripts(heldInput);
+                    }
+                    await commitSelectedNoReply(providerResult);
+                }
                 const precedingResponseSegments = [];
                 for (const [segmentOrdinal, segment] of (providerResult.precedingResponseSegments ?? []).entries()) {
                     const resolvedDeliveryContext = resolveAssistantReplyDeliveryContextForSegment({
@@ -1257,8 +1678,16 @@ export async function sendAssistantMessageLocal(input) {
                         continue;
                     }
                     precedingResponseSegments.push({
+                        ...(segment.contextReferences === undefined
+                            ? {}
+                            : {
+                                contextReferences: segment.contextReferences?.map((reference) => ({ ...reference })) ?? null,
+                            }),
                         deliveryContext: resolvedDeliveryContext.context,
                         response: segment.response,
+                        ...(segment.transcriptResponse === undefined
+                            ? {}
+                            : { transcriptResponse: segment.transcriptResponse }),
                         media: segment.media ?? [],
                         ...(segment.targetInputId
                             ? {
@@ -1274,7 +1703,7 @@ export async function sendAssistantMessageLocal(input) {
                             context: segment.deliveryContext ?? null,
                             input: currentInput,
                         }),
-                        rawResponse: segment.response,
+                        rawResponse: segment.transcriptResponse ?? segment.response,
                         session: currentSession,
                         sharedPlan,
                     });
@@ -1283,11 +1712,14 @@ export async function sendAssistantMessageLocal(input) {
                         response,
                     }) ?? response;
                 });
-                const providerResumeStateAction = resolveAssistantProviderResumeStateAction({
-                    codexThreadId: providerResult.codexThreadId ?? null,
-                    threadScope,
-                });
-                if (providerResumeStateAction === 'clear') {
+                const providerResumeStateAction = providerRequestOrdinal === 1
+                    ? 'clear'
+                    : resolveAssistantProviderResumeStateAction({
+                        codexThreadId: providerResult.codexThreadId ?? null,
+                        threadScope,
+                    });
+                if (providerRequestOrdinal === 0 &&
+                    providerResumeStateAction === 'clear') {
                     currentSession = await clearAssistantSessionCodexResumeState({
                         session: currentSession,
                         vault: input.vault,
@@ -1307,7 +1739,10 @@ export async function sendAssistantMessageLocal(input) {
                     });
                 const rawTranscriptResponseText = noReplySelected
                     ? null
-                    : providerResult.transcriptResponse;
+                    : providerResult.transcriptResponse ??
+                        (providerResult.responseCard
+                            ? renderAssistantResponseCardTranscriptText(providerResult.responseCard)
+                            : null);
                 const transcriptResponseText = rawTranscriptResponseText === null
                     ? null
                     : resolveAssistantPersistedReplyText({
@@ -1359,9 +1794,8 @@ export async function sendAssistantMessageLocal(input) {
                                 return segmentInput.input;
                             }
                             return await applyAssistantAcceptedMessageTargetToDeliveryInput({
-                                acceptedInputIdsByDeliveryContextOrdinal,
+                                acceptedInputIds: acceptedInputIdsByDeliveryContextOrdinal[deliveryContextOrdinal] ?? [],
                                 action: 'native-reply',
-                                deliveryContextOrdinal,
                                 input: segmentInput.input,
                                 session: segmentInput.session,
                                 sharedPlan,
@@ -1441,9 +1875,8 @@ export async function sendAssistantMessageLocal(input) {
                     try {
                         finalDeliveryInput =
                             await applyAssistantAcceptedMessageTargetToDeliveryInput({
-                                acceptedInputIdsByDeliveryContextOrdinal,
+                                acceptedInputIds: acceptedInputIdsByDeliveryContextOrdinal[providerResult.responseDeliveryContextOrdinal] ?? [],
                                 action: 'native-reply',
-                                deliveryContextOrdinal: providerResult.responseDeliveryContextOrdinal,
                                 input: finalReplyInput,
                                 session: deliverySession,
                                 sharedPlan,
@@ -1454,6 +1887,12 @@ export async function sendAssistantMessageLocal(input) {
                         finalTargetResolutionError = normalizeAssistantDeliveryError(error);
                     }
                 }
+                if (providerResult.responseContextReferences !== undefined) {
+                    finalDeliveryInput = {
+                        ...finalDeliveryInput,
+                        outboxAutomationContextReferences: providerResult.responseContextReferences?.map((reference) => ({ ...reference })) ?? null,
+                    };
+                }
                 const deliveryOutcome = finalResponseText !== null
                     ? finalTargetResolutionError
                         ? {
@@ -1465,6 +1904,7 @@ export async function sendAssistantMessageLocal(input) {
                         }
                         : await dispatchAssistantReply({
                             input: finalDeliveryInput,
+                            card: providerResult.responseCard ?? null,
                             media: providerResult.responseMedia ?? [],
                             response: rawFinalResponseText ?? '',
                             session: deliverySession,
@@ -1578,7 +2018,8 @@ export async function sendAssistantMessageLocal(input) {
                 turnInputController.complete(result);
                 const productFeedbackCandidate = providerResult.productFeedbackCandidate ?? null;
                 const productFeedbackCandidateSink = executionContext?.hosted?.productFeedbackCandidateSink ?? null;
-                if (productFeedbackCandidate && productFeedbackCandidateSink) {
+                if (productFeedbackCandidate &&
+                    productFeedbackCandidateSink) {
                     try {
                         productFeedbackCandidateSink.acceptProductFeedbackCandidate(productFeedbackCandidate);
                     }
@@ -1596,7 +2037,8 @@ export async function sendAssistantMessageLocal(input) {
                     progressDeliveredSession: progressDeliveredSessionRef.value,
                     session: currentSession,
                 });
-                if (failedSession !== currentSession) {
+                if (providerRequestOrdinal === 1 ||
+                    failedSession !== currentSession) {
                     await runAssistantTurnBestEffort(() => saveAssistantSession(input.vault, failedSession));
                 }
                 await runAssistantTurnBestEffort(() => persistFailedAssistantPromptAttempt({
@@ -1693,15 +2135,12 @@ export async function updateAssistantSessionOptionsLocal(input) {
         },
         createIfMissing: false,
     });
-    const providerConfig = mergeAssistantProviderConfigsForProvider(input.providerOptions.provider, 
+    const providerConfig = mergeAssistantProviderConfigs(
     // Persisted targets carry the full durable provider config. Session
     // providerOptions are a derived runtime projection and omit target-only
     // fields such as the Codex executable path.
     assistantBackendTargetToProviderConfigInput(session.session.target), input.providerOptions);
     const nextTarget = createAssistantModelTarget(providerConfig) ?? session.session.target;
-    if (nextTarget.adapter !== 'codex-cli') {
-        throw new VaultCliError('ASSISTANT_PROVIDER_UNSUPPORTED', 'Assistant sessions only support Codex app-server targets.');
-    }
     const nextProviderOptions = serializeAssistantProviderSessionOptions(providerConfig);
     const continuityChanged = session.session.providerOptions.continuityFingerprint !==
         nextProviderOptions.continuityFingerprint;
@@ -1749,6 +2188,7 @@ function resolveInitialAcceptedTurnInputItems(input) {
     }
     return [
         {
+            acceptedAt: input.userTurn.turnCreatedAt,
             id: resolveDefaultInitialAcceptedTurnInputId({
                 input: input.input,
                 userTurn: input.userTurn,
@@ -1916,6 +2356,10 @@ function elapsedSince(startedAt) {
     return Math.max(0, Date.now() - startedAt);
 }
 function resolveAssistantProviderFinalResponseText(providerResult) {
+    const card = normalizeAssistantProviderResponseCard(providerResult);
+    if (card) {
+        return renderAssistantResponseCardText(card);
+    }
     const response = normalizeNullableString(providerResult.response);
     if (response) {
         return response;
@@ -1925,6 +2369,13 @@ function resolveAssistantProviderFinalResponseText(providerResult) {
     }
     throw new VaultCliError('ASSISTANT_PROVIDER_EMPTY_RESPONSE', 'Assistant provider completed without a final response. Use finish_without_reply for an intentional no-reply turn.');
 }
+function normalizeAssistantProviderResponseCard(providerResult) {
+    const card = providerResult.responseCard ?? null;
+    if (card !== null && (providerResult.responseMedia ?? []).length > 0) {
+        throw new VaultCliError('ASSISTANT_RESPONSE_CARD_MEDIA_CONFLICT', 'A response card cannot be combined with response media.');
+    }
+    return card;
+}
 function resolveAssistantProviderTranscriptText(input) {
     if (input.response === null) {
         return null;
@@ -1972,9 +2423,8 @@ async function deliverAssistantProviderReactions(input) {
         let reactionInput;
         try {
             reactionInput = await applyAssistantAcceptedMessageTargetToDeliveryInput({
-                acceptedInputIdsByDeliveryContextOrdinal: input.acceptedInputIdsByDeliveryContextOrdinal,
+                acceptedInputIds: input.acceptedInputIdsByDeliveryContextOrdinal[reaction.deliveryContextOrdinal] ?? [],
                 action: 'reaction',
-                deliveryContextOrdinal: reaction.deliveryContextOrdinal,
                 input: baseReactionInput,
                 session: deliverySession,
                 sharedPlan: input.sharedPlan,
@@ -2008,9 +2458,8 @@ async function deliverAssistantProviderReactions(input) {
     };
 }
 async function applyAssistantAcceptedMessageTargetToDeliveryInput(input) {
-    const acceptedInputIds = input.acceptedInputIdsByDeliveryContextOrdinal[input.deliveryContextOrdinal];
     const target = await resolveAssistantAcceptedMessageTarget({
-        acceptedInputIds: acceptedInputIds ?? [],
+        acceptedInputIds: input.acceptedInputIds,
         action: input.action,
         messageRef: input.targetInputId,
         route: resolveAssistantCurrentAudienceDeliveryFields({
@@ -2056,6 +2505,7 @@ function buildActiveTurnInput(input) {
             input: input.input,
             overrides: input.acceptedInput,
         }),
+        outboxAutomationContextReferences: null,
         prompt: input.acceptedInput.prompt,
         receiptMetadata: input.acceptedInput.receiptMetadata === undefined
             ? input.input.receiptMetadata