@murphai/murph 1.3.1 → 1.3.2

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

@@ -15,7 +15,7 @@ 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';
@@ -36,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';
@@ -49,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);
@@ -294,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({
@@ -326,6 +412,7 @@ 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);
@@ -343,6 +430,32 @@ export async function sendAssistantMessageLocal(input) {
                     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 }) => {
@@ -350,6 +463,7 @@ export async function sendAssistantMessageLocal(input) {
                             inputs: acceptedInputs,
                             vault: input.vault,
                         });
+                        await snapshotAnalyzeVideoAuthorities(acceptedInputs.map((acceptedInput) => acceptedInput.id));
                     },
                     admissionHook: input.activeTurnInput,
                     beforeProviderSteer: input.beforeProviderAcceptedInputs
@@ -363,6 +477,7 @@ export async function sendAssistantMessageLocal(input) {
                                 journal: acceptedInputJournal,
                                 vault: input.vault,
                             });
+                            await snapshotAnalyzeVideoAuthorities(acceptedInputJournal.inputIds);
                             const releaseProviderAcceptedInputs = await input.beforeProviderAcceptedInputs?.({
                                 ...event,
                                 turnId: receipt.turnId,
@@ -376,6 +491,7 @@ export async function sendAssistantMessageLocal(input) {
                         resolveAssistantConversationLookupKey(input),
                     ].filter((key) => key !== null),
                     sessionId: resolved.session.sessionId,
+                    signal: input.abortSignal,
                     turnId: receipt.turnId,
                     vault: input.vault,
                 });
@@ -400,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;
@@ -432,6 +549,8 @@ export async function sendAssistantMessageLocal(input) {
                     ? createAssistantProgressDelivery({
                         deliver: async (progressInput) => {
                             const deliveryContextOrdinal = progressInput.deliveryContextOrdinal ?? 0;
+                            const absoluteDeliveryContextOrdinal = providerRequestDeliveryContextBaseOrdinal +
+                                deliveryContextOrdinal;
                             const { targetInputId, ...untargetedProgressInput } = progressInput;
                             if (targetInputId) {
                                 await beforeHostedToolExecution(deliveryContextOrdinal);
@@ -440,7 +559,7 @@ export async function sendAssistantMessageLocal(input) {
                                 ? {
                                     ...untargetedProgressInput,
                                     input: await applyAssistantAcceptedMessageTargetToDeliveryInput({
-                                        acceptedInputIds: resolveAcceptedInputIdsThroughDeliveryContextOrdinal(deliveryContextOrdinal),
+                                        acceptedInputIds: resolveAcceptedInputIdsThroughDeliveryContextOrdinal(absoluteDeliveryContextOrdinal),
                                         action: 'native-reply',
                                         input: progressInput.input,
                                         session: progressInput.session,
@@ -534,6 +653,9 @@ export async function sendAssistantMessageLocal(input) {
                             messageInput: currentInput,
                             session: currentSession,
                         }),
+                        getAnalyzeVideoAttachmentAuthorities: () => [
+                            ...analyzeVideoAttachmentAuthorities.values(),
+                        ],
                         getConversationScope: () => resolveAssistantConversationScope(sharedPlan.conversationPolicy.audience),
                         getUserActionAcceptedInputIds: () => resolveAssistantUserActionAcceptedInputIds({
                             acceptedInputItems: acceptedInputItemsForProviderRequest,
@@ -651,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;
@@ -685,13 +809,34 @@ 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,
@@ -704,7 +849,7 @@ export async function sendAssistantMessageLocal(input) {
                             inputs: acceptedInputItems,
                         });
                     }
-                    let acceptedInputJournal = preProviderSteerJournal ??
+                    const acceptedInputJournal = preProviderSteerJournal ??
                         await runtimeState.turns.acceptedInputs.append({
                             inputs: acceptedInputItems,
                             sessionId: resolved.session.sessionId,
@@ -715,23 +860,17 @@ export async function sendAssistantMessageLocal(input) {
                         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,
@@ -754,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 {
@@ -795,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;
                     }
@@ -926,113 +1077,402 @@ export async function sendAssistantMessageLocal(input) {
                     await drainLiveSteeredActiveTurnInputs({
                         continuation: providerRequestContinuation,
                         sessionId: currentSession.sessionId,
-                        throughDeliveryContextOrdinal,
+                        throughDeliveryContextOrdinal: providerRequestDeliveryContextBaseOrdinal +
+                            throughDeliveryContextOrdinal,
                     });
                 };
-                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 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();
+                        }
+                        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.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,
+                                });
+                            providerRequestAcceptedInputIds =
+                                providerRequestJournal?.inputIds ?? acceptedInputIdsForProviderRequest;
+                            providerRequestAcceptedInputItems =
+                                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 =
+                                providerRequestJournal?.inputIds ?? providerRequestAcceptedInputIds;
+                            providerRequestAcceptedInputItems =
+                                providerRequestJournal?.inputs ?? providerRequestAcceptedInputItems;
+                            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 ||
+                            !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,
-                            vault: input.vault,
                         });
-                    },
-                    onProviderRequestPlanned: async (event) => {
-                        providerRequestContinuation = event.codexContinuation;
-                        providerRequestJournal =
-                            await runtimeState.turns.acceptedInputs.recordProviderRequest({
-                                continuation: event.codexContinuation,
-                                ordinal: providerRequestOrdinal,
-                                providerAttemptId: event.providerAttemptId,
-                                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,
                             });
-                        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,
+                        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,
                         });
-                    },
-                    route,
-                    plan: sharedPlan,
-                    profile: {
-                        threadScope,
-                    },
-                    providerRequestOrdinal,
-                    ...(providerStartAtPreProviderSetupDone
-                        ? {
-                            providerStartCriticalPath: providerStartAtPreProviderSetupDone,
+                        if (requestInput.allowFailedNoReplyRecovery &&
+                            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: [],
+                                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,
+                            };
                         }
-                        : {}),
-                    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,
@@ -1047,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,
@@ -1059,37 +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({
@@ -1101,235 +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: [],
-                            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 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;
+                    providerResult = selectAssistantGroupProviderResult(providerResult);
                 }
-                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;
-                }
-                await drainLiveSteeredActiveTurnInputs({
-                    continuation: providerResult.codexContinuation,
-                    sessionId: providerResult.session.sessionId,
-                    throughDeliveryContextOrdinal: providerResult.responseDeliveryContextOrdinal,
-                });
-                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,
-                    ...(providerRequestStartedAtMs === null
-                        ? {}
-                        : { occurredAt: new Date(providerRequestStartedAtMs).toISOString() }),
-                    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,
@@ -1349,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({
@@ -1377,6 +1678,11 @@ 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
@@ -1406,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,
@@ -1578,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
                         ? {
@@ -1722,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({
@@ -2189,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