@murphai/murph 1.2.0 → 1.2.4

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

@@ -1,6 +1,6 @@
 import { assistantAskResultSchema, } from '@murphai/operator-config/assistant-cli-contracts';
 import { assistantBackendTargetToProviderConfigInput, createAssistantModelTarget, createDefaultLocalAssistantModelTarget, } from '@murphai/operator-config/assistant-backend';
-import { appendAssistantTranscriptEntriesWithRefs, redactAssistantDisplayPath, resolveAssistantSession, saveAssistantSession, } from './store.js';
+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';
@@ -12,7 +12,8 @@ import { emitHostedAssistantContextTimingTrace, emitHostedAssistantContextSessio
 import { emitHostedAssistantTurnTimingTrace } from './hosted-turn-timing.js';
 import { deliverAssistantPrecedingReplies, deliverAssistantReaction, deliverAssistantReply as dispatchAssistantReply, deliverAssistantProgressUpdate, finalizeAssistantTurnFromDeliveryOutcome as finalizeDeliveredAssistantTurn, resolveAssistantCurrentAudienceDeliveryFields, resolveAssistantHostedDeliveryIdempotency, supportsAssistantCurrentAudienceMessageReaction, } from './delivery-service.js';
 import { applyAssistantReplyDeliveryContext, applyAssistantReplyDeliveryContextOverrides, pickAssistantReplyDeliveryContext, } from './reply-delivery-context.js';
-import { clearAssistantSessionCodexResumeState, persistAssistantNoReplyTranscriptMarkers, persistAssistantTurnAndSession as finalizeAssistantTurnArtifacts, } from './turn-finalizer.js';
+import { applyAssistantSessionCodexResumeStateAction, clearAssistantSessionCodexResumeState, persistAssistantNoReplyTranscriptMarkers, persistAssistantTurnAndSession as finalizeAssistantTurnArtifacts, resolveAssistantProviderResumeStateAction, } 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';
@@ -21,21 +22,25 @@ import { normalizeAssistantExecutionContext, } from './execution-context.js';
 import { resolveAssistantExecutionDefaultTarget } from './execution-context.js';
 import { resolveAssistantExecutionOperatorDefaults } from './execution-context.js';
 import { executeCodexTurnWithRecovery, resolveAssistantCodexThreadScope, } from './codex-turn-runner.js';
+import { readCodexThreadCompatibilityFingerprint, readCodexThreadRouteFingerprint, } from './codex-thread-route.js';
+import { resolveAssistantExecutionPlan } from './execution-plan.js';
 import { normalizeAssistantAskResultForReturn, serializeAssistantSessionForResult, } from './service-result.js';
 import { persistFailedAssistantPromptAttempt } from './prompt-attempts.js';
 import { resolveAssistantTurnRoute } from './service-turn-routes.js';
 import { recordAdditionalAssistantUsageEvents, recordAssistantUsageEvent, } from './service-usage.js';
 import { maybeRunAssistantRuntimeMaintenance } from './runtime-budgets.js';
 import {} from './turn-input.js';
-import { startAssistantChannelTypingIndicator, stopAssistantChannelTypingIndicator, } from './channel-typing.js';
-import { createAssistantProgressDelivery, shouldCreateAssistantProgressDelivery, } from './turn-progress.js';
+import { assistantDeliveryOutcomeSupersedesTypingIndicator, startAssistantChannelTypingIndicator, stopAssistantChannelTypingIndicator, } from './channel-typing.js';
+import { createAssistantProgressDelivery, resolveAssistantProductFeedbackAcceptedInputIds, shouldCreateAssistantProgressDelivery, } from './turn-progress.js';
 import { createAssistantHostedToolContext, } from './hosted-tool-context.js';
-import { resolveAssistantPhoneCallAcceptedInputIds, } from '../assistant-codex/dynamic-tools/phone-calls.js';
+import { resolveAssistantUserActionAcceptedInputIds, } from '../assistant-codex/dynamic-tools/phone-calls.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';
 import { createAssistantActiveTurnNotActiveError, createAssistantActiveTurnInputController, steerAssistantActiveTurnInputWithStatus, } from './active-turn-input-controller.js';
 import { normalizeNullableString, } from './shared.js';
+import { resolveAssistantConversationScope } from './conversation-policy.js';
+import { assistantChannelSupportsReplyBubbles, stripAssistantReplyBubbleDelimiters, } from './reply-bubbles.js';
 import { withAssistantTurnLock } from './turn-lock.js';
 export { buildResolveAssistantSessionInput } from './session-resolution.js';
 const DEFAULT_INITIAL_ACCEPTED_TURN_INPUT_ID = 'initial';
@@ -61,6 +66,16 @@ function hasHostedTextDeliveryForChannel(input) {
             return false;
     }
 }
+function resolveAssistantPersistedReplyText(input) {
+    const deliveryFields = resolveAssistantCurrentAudienceDeliveryFields({
+        input: input.messageInput,
+        session: input.session,
+        sharedPlan: input.sharedPlan,
+    });
+    return assistantChannelSupportsReplyBubbles(deliveryFields.channel)
+        ? stripAssistantReplyBubbleDelimiters(input.rawResponse)
+        : input.rawResponse;
+}
 function isHostedOptionalProgressDeliveryAvailable(input) {
     const hosted = input.executionContext?.hosted;
     if (!hosted) {
@@ -137,6 +152,64 @@ async function persistUserTurn(input, resolved, plan, turnId) {
         userPersisted,
     };
 }
+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.";
+async function completeUnverifiedExternalAudienceTurn(input) {
+    let turnCreatedAt = input.userTurn.turnCreatedAt;
+    if (!input.userTurn.userPersisted) {
+        const persisted = await appendUserTranscriptEntryForTurn({
+            detail: 'user prompt persisted before deterministic audience-safety reply',
+            sessionId: input.session.sessionId,
+            text: input.message.prompt,
+            turnId: input.turnId,
+            vault: input.message.vault,
+        });
+        turnCreatedAt = persisted.createdAt;
+    }
+    await appendAssistantTranscriptEntries(input.message.vault, input.session.sessionId, [{
+            createdAt: turnCreatedAt,
+            kind: 'assistant',
+            text: UNVERIFIED_EXTERNAL_AUDIENCE_RESPONSE,
+        }]);
+    const updatedAt = new Date().toISOString();
+    const savedSession = await saveAssistantSession(input.message.vault, {
+        ...input.session,
+        lastTurnAt: updatedAt,
+        turnCount: input.session.turnCount + 1,
+        updatedAt,
+    });
+    const outcome = await dispatchAssistantReply({
+        input: input.message,
+        response: UNVERIFIED_EXTERNAL_AUDIENCE_RESPONSE,
+        session: savedSession,
+        sharedPlan: input.plan,
+        turnId: input.turnId,
+    });
+    await finalizeDeliveredAssistantTurn({
+        outcome,
+        response: UNVERIFIED_EXTERNAL_AUDIENCE_RESPONSE,
+        turnId: input.turnId,
+        vault: input.message.vault,
+    });
+    return {
+        outcome,
+        result: normalizeAssistantAskResultForReturn({
+            delivery: outcome.kind === 'sent' ? outcome.delivery : null,
+            deliveryDeferred: outcome.kind === 'queued',
+            deliveryError: outcome.kind === 'queued' || outcome.kind === 'failed'
+                ? outcome.error
+                : null,
+            deliveryIntentId: outcome.kind === 'sent' || outcome.kind === 'queued' || outcome.kind === 'failed'
+                ? outcome.intentId
+                : null,
+            media: outcome.media,
+            prompt: input.message.prompt,
+            response: UNVERIFIED_EXTERNAL_AUDIENCE_RESPONSE,
+            session: outcome.session,
+            status: 'completed',
+            vault: redactAssistantDisplayPath(input.message.vault),
+        }),
+    };
+}
 export async function openAssistantConversationLocal(input) {
     const defaults = await resolveAssistantOperatorDefaults();
     return resolveAssistantSession(buildResolveAssistantSessionInput(input, defaults, createDefaultLocalAssistantModelTarget()));
@@ -159,9 +232,6 @@ export async function sendAssistantMessageLocal(input) {
             throw createAssistantActiveTurnNotActiveError();
         }
     }
-    await runAssistantTurnBestEffort(() => maybeRunAssistantRuntimeMaintenance({
-        vault: input.vault,
-    }));
     const executionContext = normalizeAssistantExecutionContext(input.executionContext);
     const boundaryDefaultTarget = resolveAssistantExecutionDefaultTarget({
         executionContext,
@@ -172,7 +242,7 @@ export async function sendAssistantMessageLocal(input) {
         executionContext,
     });
     const turnLockWaitStartedAt = Date.now();
-    return withAssistantTurnLock({
+    const runLockedTurn = () => withAssistantTurnLock({
         abortSignal: input.abortSignal,
         vault: input.vault,
         run: async () => {
@@ -208,19 +278,15 @@ export async function sendAssistantMessageLocal(input) {
                 prompt: input.prompt,
                 deliveryRequested: input.deliverResponse === true,
             });
-            await recordAssistantDiagnosticEvent({
-                vault: input.vault,
-                component: 'assistant',
-                kind: 'turn.started',
-                message: `Started assistant turn for session ${resolved.session.sessionId}.`,
-                sessionId: resolved.session.sessionId,
-                turnId: receipt.turnId,
-                counterDeltas: {
-                    turnsStarted: 1,
-                },
-            });
             let responseText = null;
             let userTurn = null;
+            const typingIndicatorDeliveryFields = input.deliverResponse === true
+                ? resolveAssistantCurrentAudienceDeliveryFields({
+                    input,
+                    session: resolved.session,
+                    sharedPlan,
+                })
+                : null;
             const typingIndicator = startAssistantChannelTypingIndicator({
                 channelDependencies: executionContext?.hosted?.channelTypingDependencies ?? null,
                 input,
@@ -232,7 +298,22 @@ export async function sendAssistantMessageLocal(input) {
                 value: null,
             };
             let currentSession = resolved.session;
+            let deliverySupersededTypingIndicator = false;
             try {
+                if (resolveAssistantConversationScope(sharedPlan.conversationPolicy.audience) === 'unverified-external') {
+                    userTurn = await persistUserTurn(input, resolved, sharedPlan, receipt.turnId);
+                    responseText = UNVERIFIED_EXTERNAL_AUDIENCE_RESPONSE;
+                    const completed = await completeUnverifiedExternalAudienceTurn({
+                        message: input,
+                        plan: sharedPlan,
+                        session: resolved.session,
+                        turnId: receipt.turnId,
+                        userTurn,
+                    });
+                    deliverySupersededTypingIndicator =
+                        assistantDeliveryOutcomeSupersedesTypingIndicator(completed.outcome.kind);
+                    return completed.result;
+                }
                 const turnInputController = createAssistantActiveTurnInputController({
                     acceptedInputValidator: async ({ acceptedInputs }) => {
                         await assertAssistantAcceptedTurnInputItemInputsAssistantInputEventsExist({
@@ -241,6 +322,11 @@ export async function sendAssistantMessageLocal(input) {
                         });
                     },
                     admissionHook: input.activeTurnInput,
+                    beforeProviderSteer: input.beforeProviderAcceptedInputs
+                        ? async (event) => {
+                            await input.beforeProviderAcceptedInputs?.(event);
+                        }
+                        : undefined,
                     conversationKeys: [
                         resolved.session.binding.conversationKey,
                         resolveAssistantConversationLookupKey(input),
@@ -293,9 +379,10 @@ export async function sendAssistantMessageLocal(input) {
                 const hostedExecutionContext = executionContext?.hosted ?? null;
                 let acceptedInputIdsForProviderRequest = initialAcceptedInputJournal.inputIds;
                 let acceptedInputItemsForProviderRequest = initialAcceptedInputJournal.inputs;
+                let beforeHostedToolExecution = async () => { };
                 const refreshTypingIndicatorAfterProgress = () => {
                     void runAssistantTurnBestEffort(async () => {
-                        await typingIndicator?.refreshNow?.();
+                        await typingIndicator?.refreshAfterMessage?.();
                     });
                 };
                 const progressDelivery = shouldCreateAssistantProgressDelivery(input) &&
@@ -359,17 +446,32 @@ export async function sendAssistantMessageLocal(input) {
                     && vaultFileSendTargetFingerprint !== null;
                 const hostedToolContext = hostedExecutionContext
                     ? createAssistantHostedToolContext({
+                        actionApprovalPort,
+                        assistantConfigurationTool: hostedExecutionContext.assistantConfigurationTool ?? null,
                         connectedApps: hostedExecutionContext.connectedApps ?? null,
                         computerToolsAvailable: hostedComputerToolsAvailable,
+                        beforeToolExecution: () => beforeHostedToolExecution(),
+                        familyPlanTool: hostedExecutionContext.familyPlanTool ?? null,
+                        groupTool: hostedExecutionContext.groupTool ?? null,
+                        newsletterTool: hostedExecutionContext.newsletterTool ?? null,
+                        personalizationTool: hostedExecutionContext.personalizationTool ?? null,
+                        planUsageTool: hostedExecutionContext.planUsageTool ?? null,
                         phoneCalls: hostedExecutionContext.phoneCalls ?? null,
+                        ...(hostedExecutionContext.currentAssistantPreferenceInputId
+                            ? {
+                                getAssistantPreferenceInputId: hostedExecutionContext.currentAssistantPreferenceInputId,
+                            }
+                            : {}),
                         getDeliveryContext: () => ({
                             messageInput: currentInput,
                             session: currentSession,
                         }),
-                        getPhoneCallAcceptedInputIds: () => resolveAssistantPhoneCallAcceptedInputIds({
+                        getConversationScope: () => resolveAssistantConversationScope(sharedPlan.conversationPolicy.audience),
+                        getUserActionAcceptedInputIds: () => resolveAssistantUserActionAcceptedInputIds({
                             acceptedInputItems: acceptedInputItemsForProviderRequest,
                             turnTrigger: currentInput.turnTrigger ?? null,
                         }),
+                        getProductFeedbackAcceptedInputIds: () => resolveAssistantProductFeedbackAcceptedInputIds(acceptedInputItemsForProviderRequest),
                         messageInput: input,
                         ...(vaultFileSendAvailable && actionApprovalPort
                             ? {
@@ -385,18 +487,30 @@ export async function sendAssistantMessageLocal(input) {
                                     if (!resolveAssistantVaultFileSendTargetFingerprint(deliveryFields)) {
                                         throw new VaultCliError('ASSISTANT_VAULT_FILE_TARGET_UNAVAILABLE', 'Secure vault-file approval requires a concrete destination.');
                                     }
+                                    const hostedDelivery = resolveAssistantHostedDeliveryIdempotency({
+                                        audience: sharedPlan.conversationPolicy.audience,
+                                        channel: deliveryFields.channel,
+                                        deliveryFields,
+                                        input: currentInput,
+                                        session: currentSession,
+                                    });
                                     const result = await requestAssistantVaultFileSend({
                                         actionApprovalPort,
                                         actorId: deliveryFields.actorId,
+                                        answeredMailboxItemIds: currentInput.answeredMailboxItemIds ?? [],
                                         bindingDelivery: deliveryFields.bindingDelivery,
                                         channel: deliveryFields.channel,
                                         deliverySource: deliveryFields.deliverySource,
+                                        deliveryTransportIdempotent: hostedDelivery.deliveryTransportIdempotent,
                                         explicitTarget: deliveryFields.explicitTarget,
                                         identityId: deliveryFields.identityId,
                                         ref,
                                         replyToMessageId: deliveryFields.replyToMessageId,
+                                        sessionId: currentSession.sessionId,
                                         threadId: deliveryFields.threadId,
                                         threadIsDirect: deliveryFields.threadIsDirect,
+                                        turnId: currentUserTurn.turnId,
+                                        turnTrigger: currentInput.turnTrigger ?? null,
                                         vault: currentInput.vault,
                                     });
                                     if (result.status === 'pending') {
@@ -570,8 +684,6 @@ export async function sendAssistantMessageLocal(input) {
                     turnLockWaitMs,
                 });
                 let providerRequestJournal = null;
-                let codexUnsafeResumeStateInvalidated = false;
-                const noReplyTranscriptMarkerDeliveryContextOrdinals = new Set();
                 let providerRequestContinuation = null;
                 let providerRequestAcceptedInputIds = acceptedInputIdsForProviderRequest;
                 let providerRequestAcceptedInputItems = acceptedInputItemsForProviderRequest;
@@ -628,37 +740,16 @@ export async function sendAssistantMessageLocal(input) {
                         acceptedInputItemsForProviderRequest = providerRequestAcceptedInputItems;
                     }
                 };
+                beforeHostedToolExecution = async () => {
+                    await drainLiveSteeredActiveTurnInputs({
+                        continuation: providerRequestContinuation,
+                        sessionId: currentSession.sessionId,
+                    });
+                };
                 const providerOutcome = await executeCodexTurnWithRecovery({
                     acceptedInputItems: providerRequestAcceptedInputItems,
                     activeTurnSteering: turnInputController,
                     input: currentInput,
-                    onCodexThreadHistoryUnsafe: async (event) => {
-                        if (!codexUnsafeResumeStateInvalidated) {
-                            currentSession = await clearAssistantSessionCodexResumeStateIfNeeded({
-                                action: resolveProviderResumeStateAction({
-                                    codexThreadHistoryUnsafe: true,
-                                    codexThreadId: null,
-                                    threadScope,
-                                }),
-                                session: currentSession,
-                                vault: input.vault,
-                            });
-                            codexUnsafeResumeStateInvalidated = true;
-                        }
-                        const deliveryContextOrdinal = event?.deliveryContextOrdinal;
-                        if (typeof deliveryContextOrdinal !== 'number' ||
-                            noReplyTranscriptMarkerDeliveryContextOrdinals.has(deliveryContextOrdinal)) {
-                            return;
-                        }
-                        await persistAssistantNoReplyTranscriptMarkers({
-                            deliveryContextOrdinals: [deliveryContextOrdinal],
-                            sessionId: currentSession.sessionId,
-                            turnCreatedAt: currentUserTurn.turnCreatedAt,
-                            turnId: currentUserTurn.turnId,
-                            vault: input.vault,
-                        });
-                        noReplyTranscriptMarkerDeliveryContextOrdinals.add(deliveryContextOrdinal);
-                    },
                     onFinishWithoutReplyAccepted: async (event) => {
                         await drainLiveSteeredActiveTurnInputs({
                             continuation: providerRequestContinuation,
@@ -691,6 +782,15 @@ export async function sendAssistantMessageLocal(input) {
                                 }),
                         });
                     },
+                    onFinishWithoutReplyRecorded: async (event) => {
+                        await persistAssistantNoReplyTranscriptMarkers({
+                            deliveryContextOrdinals: [event.deliveryContextOrdinal],
+                            sessionId: currentSession.sessionId,
+                            turnCreatedAt: currentUserTurn.turnCreatedAt,
+                            turnId: currentUserTurn.turnId,
+                            vault: input.vault,
+                        });
+                    },
                     onProviderRequestPlanned: async (event) => {
                         providerRequestContinuation = event.codexContinuation;
                         providerRequestJournal =
@@ -706,6 +806,9 @@ export async function sendAssistantMessageLocal(input) {
                             providerRequestJournal?.inputs ?? acceptedInputItemsForProviderRequest;
                         acceptedInputIdsForProviderRequest = providerRequestAcceptedInputIds;
                         acceptedInputItemsForProviderRequest = providerRequestAcceptedInputItems;
+                        return await input.beforeProviderAcceptedInputs?.({
+                            acceptedInputs: providerRequestAcceptedInputItems,
+                        });
                     },
                     onProviderRequestStarted: (event) => {
                         const startedAtMs = Date.parse(event.startedAt);
@@ -716,13 +819,13 @@ export async function sendAssistantMessageLocal(input) {
                             return;
                         }
                         return currentInput.onProviderRequestStarted({
+                            ...event,
                             acceptedInputIds: providerRequestAcceptedInputIds,
                             admissionMs,
                             preProviderSetupMs,
                             promptBuildMs,
                             providerRequestOrdinal: event.providerRequestOrdinal ?? providerRequestOrdinal,
                             sessionResolveMs,
-                            startedAt: event.startedAt,
                             turnLockWaitMs,
                         });
                     },
@@ -789,9 +892,22 @@ export async function sendAssistantMessageLocal(input) {
                         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,
+                        });
+                    }
                     const usageRecordStartedAt = Date.now();
                     await recordAssistantUsageEvent({
                         executionContext,
+                        providerRequestAcceptedInputIds,
                         providerRequestOrdinal,
                         providerRequestOutcome: providerOutcome.providerRequestOutcome,
                         providerResult: failedProviderResult,
@@ -810,33 +926,30 @@ export async function sendAssistantMessageLocal(input) {
                         additionalUsages: providerOutcome.additionalUsages,
                         effectiveEnv: currentInput.turnEnvironment?.env ?? process.env,
                         executionContext,
+                        providerRequestAcceptedInputIds,
                         providerResult: failedProviderResult,
                         turnId: currentUserTurn.turnId,
                     });
-                    const acceptedNoReplyOrdinals = providerOutcome.acceptedNoReplyDeliveryContextOrdinals ?? [];
-                    const latestAcceptedDeliveryContextOrdinal = replyDeliveryContexts.length - 1;
-                    const recoverableNoReplyDeliveryContextOrdinal = latestAcceptedDeliveryContextOrdinal >= 0 &&
-                        acceptedNoReplyOrdinals.includes(latestAcceptedDeliveryContextOrdinal)
-                        ? latestAcceptedDeliveryContextOrdinal
-                        : null;
-                    const failedProviderResumeStateAction = resolveProviderResumeStateAction({
-                        codexThreadHistoryUnsafe: providerOutcome.codexThreadHistoryUnsafe === true ||
-                            acceptedNoReplyOrdinals.length > 0,
+                    const failedProviderResumeStateAction = resolveAssistantProviderResumeStateAction({
                         codexThreadId: providerOutcome.codexThreadId ?? null,
                         threadScope,
                     });
-                    if (!codexUnsafeResumeStateInvalidated &&
-                        failedProviderResumeStateAction === 'clear') {
+                    if (progressDeliveredSessionRef.value) {
                         currentSession = applyAssistantProgressDeliveredSession({
                             progressDeliveredSession: progressDeliveredSessionRef.value,
                             session: providerOutcome.session,
                         });
-                        currentSession = await clearAssistantSessionCodexResumeStateIfNeeded({
-                            action: failedProviderResumeStateAction,
-                            session: currentSession,
-                            vault: input.vault,
-                        });
                     }
+                    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,
+                    });
                     if (recoverableNoReplyDeliveryContextOrdinal !== null) {
                         turnInputController.close();
                         await runtimeState.turns.acceptedInputs.updateAdmissionState({
@@ -847,10 +960,10 @@ export async function sendAssistantMessageLocal(input) {
                         const failedNoReplySession = currentSession;
                         const failedNoReplyProviderResult = {
                             acceptedNoReplyDeliveryContextOrdinals: acceptedNoReplyOrdinals,
-                            assistantContractFingerprint: '',
+                            assistantContractFingerprint: providerOutcome.assistantContractFingerprint,
                             attemptCount: providerOutcome.attemptCount,
                             codexContinuation: providerOutcome.codexContinuation,
-                            codexThreadHistoryUnsafe: true,
+                            codexRolloutRelativePath: providerOutcome.codexRolloutRelativePath,
                             codexThreadId: providerOutcome.codexThreadId,
                             finalAction: {
                                 kind: 'none',
@@ -860,11 +973,13 @@ export async function sendAssistantMessageLocal(input) {
                             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,
@@ -957,10 +1072,6 @@ export async function sendAssistantMessageLocal(input) {
                         turnInputController.complete(result);
                         return result;
                     }
-                    await drainLiveSteeredActiveTurnInputs({
-                        continuation: providerOutcome.codexContinuation,
-                        sessionId: providerOutcome.session.sessionId,
-                    });
                     throw providerOutcome.error;
                 }
                 providerResult = providerOutcome.providerTurn;
@@ -994,14 +1105,24 @@ export async function sendAssistantMessageLocal(input) {
                     acceptedInputIdsForProviderRequest = providerRequestAcceptedInputIds;
                     acceptedInputItemsForProviderRequest = providerRequestAcceptedInputItems;
                 }
+                await drainLiveSteeredActiveTurnInputs({
+                    continuation: providerResult.codexContinuation,
+                    sessionId: providerResult.session.sessionId,
+                });
                 currentSession = applyAssistantProgressDeliveredSession({
                     progressDeliveredSession: progressDeliveredSessionRef.value,
                     session: providerResult.session,
                 });
-                responseText = providerResult.response;
+                responseText = resolveAssistantPersistedReplyText({
+                    messageInput: currentInput,
+                    rawResponse: providerResult.response,
+                    session: currentSession,
+                    sharedPlan,
+                });
                 const usageRecordStartedAt = Date.now();
                 await recordAssistantUsageEvent({
                     executionContext,
+                    providerRequestAcceptedInputIds,
                     providerRequestOrdinal,
                     providerResult,
                     turnId: currentUserTurn.turnId,
@@ -1019,13 +1140,24 @@ export async function sendAssistantMessageLocal(input) {
                     additionalUsages: providerResult.additionalUsages,
                     effectiveEnv: currentInput.turnEnvironment?.env ?? process.env,
                     executionContext,
+                    providerRequestAcceptedInputIds,
                     providerResult,
                     turnId: currentUserTurn.turnId,
                 });
-                await drainLiveSteeredActiveTurnInputs({
-                    continuation: providerResult.codexContinuation,
-                    sessionId: providerResult.session.sessionId,
+                const resolvedFinalReplyDeliveryContext = resolveAssistantReplyDeliveryContextForSegment({
+                    contexts: replyDeliveryContexts,
+                    deliveryContextOrdinal: providerResult.responseDeliveryContextOrdinal,
                 });
+                if (resolvedFinalReplyDeliveryContext.invalidDeliveryContextOrdinal !==
+                    null) {
+                    throw new VaultCliError('ASSISTANT_DELIVERY_CONTEXT_ORDINAL_INVALID', 'Assistant final reply referenced an invalid delivery context ordinal.');
+                }
+                const finalReplyInput = resolvedFinalReplyDeliveryContext.context
+                    ? applyAssistantReplyDeliveryContext({
+                        context: resolvedFinalReplyDeliveryContext.context,
+                        input: currentInput,
+                    })
+                    : currentInput;
                 turnInputController.close();
                 await runtimeState.turns.acceptedInputs.updateAdmissionState({
                     admissionState: 'commit-started',
@@ -1063,27 +1195,51 @@ export async function sendAssistantMessageLocal(input) {
                         media: segment.media ?? [],
                     });
                 }
-                const precedingResponses = precedingResponseSegments.map((segment) => segment.response);
-                const providerResumeStateAction = resolveProviderResumeStateAction({
-                    codexThreadHistoryUnsafe: providerResult.codexThreadHistoryUnsafe === true ||
-                        providerResult.finalAction?.kind === 'none',
+                const precedingResponses = precedingResponseSegments.map((segment) => resolveAssistantPersistedReplyText({
+                    messageInput: applyAssistantReplyDeliveryContext({
+                        context: segment.deliveryContext ?? null,
+                        input: currentInput,
+                    }),
+                    rawResponse: segment.response,
+                    session: currentSession,
+                    sharedPlan,
+                }));
+                const providerResumeStateAction = resolveAssistantProviderResumeStateAction({
                     codexThreadId: providerResult.codexThreadId ?? null,
                     threadScope,
                 });
-                if (!codexUnsafeResumeStateInvalidated) {
-                    currentSession = await clearAssistantSessionCodexResumeStateIfNeeded({
-                        action: providerResumeStateAction,
+                if (providerResumeStateAction === 'clear') {
+                    currentSession = await clearAssistantSessionCodexResumeState({
                         session: currentSession,
                         vault: input.vault,
                     });
                 }
                 const noReplySelected = providerResult.finalAction?.kind === 'none';
-                const finalResponseText = noReplySelected
+                const rawFinalResponseText = noReplySelected
                     ? null
                     : resolveAssistantProviderFinalResponseText(providerResult);
+                const finalResponseText = rawFinalResponseText === null
+                    ? null
+                    : resolveAssistantPersistedReplyText({
+                        messageInput: finalReplyInput,
+                        rawResponse: rawFinalResponseText,
+                        session: currentSession,
+                        sharedPlan,
+                    });
+                const rawTranscriptResponseText = noReplySelected
+                    ? null
+                    : providerResult.transcriptResponse;
+                const transcriptResponseText = rawTranscriptResponseText === null
+                    ? null
+                    : resolveAssistantPersistedReplyText({
+                        messageInput: finalReplyInput,
+                        rawResponse: rawTranscriptResponseText,
+                        session: currentSession,
+                        sharedPlan,
+                    });
                 const assistantTranscriptText = resolveAssistantProviderTranscriptText({
                     media: providerResult.responseMedia,
-                    response: finalResponseText,
+                    response: transcriptResponseText,
                 });
                 const turnArtifactsStartedAt = Date.now();
                 const session = await finalizeAssistantTurnArtifacts({
@@ -1148,7 +1304,25 @@ export async function sendAssistantMessageLocal(input) {
                         }));
                     }
                 }
-                for (const precedingOutcome of precedingDeliveryOutcomes) {
+                for (const [precedingOutcomeIndex, precedingOutcome] of precedingDeliveryOutcomes.entries()) {
+                    const precedingSegment = precedingResponseSegments[precedingOutcomeIndex] ?? null;
+                    const precedingDeliveryFields = precedingSegment
+                        ? resolveAssistantCurrentAudienceDeliveryFields({
+                            input: applyAssistantReplyDeliveryContext({
+                                context: precedingSegment.deliveryContext ?? null,
+                                input: currentInput,
+                            }),
+                            session: precedingOutcome.session,
+                            sharedPlan,
+                        })
+                        : null;
+                    deliverySupersededTypingIndicator =
+                        deliverySupersededTypingIndicator ||
+                            assistantDeliveryOutcomeSupersedesTypingIndicatorForTarget({
+                                deliveryFields: precedingDeliveryFields,
+                                kind: precedingOutcome.kind,
+                                typingIndicatorDeliveryFields,
+                            });
                     if (precedingOutcome.kind !== 'failed') {
                         continue;
                     }
@@ -1167,9 +1341,9 @@ export async function sendAssistantMessageLocal(input) {
                 const replyDispatchStartedAt = Date.now();
                 const deliveryOutcome = finalResponseText !== null
                     ? await dispatchAssistantReply({
-                        input: currentInput,
+                        input: finalReplyInput,
                         media: providerResult.responseMedia ?? [],
-                        response: finalResponseText,
+                        response: rawFinalResponseText ?? '',
                         session: deliverySession,
                         sharedPlan,
                         turnId: currentUserTurn.turnId,
@@ -1178,6 +1352,21 @@ export async function sendAssistantMessageLocal(input) {
                         precedingDeliveryOutcomes,
                         session: deliverySession,
                     });
+                const replyIntentReadyAt = finalResponseText === null ? null : Date.now();
+                const finalReplyDeliveryFields = finalResponseText !== null
+                    ? resolveAssistantCurrentAudienceDeliveryFields({
+                        input: finalReplyInput,
+                        session: deliveryOutcome.session,
+                        sharedPlan,
+                    })
+                    : null;
+                deliverySupersededTypingIndicator =
+                    deliverySupersededTypingIndicator ||
+                        assistantDeliveryOutcomeSupersedesTypingIndicatorForTarget({
+                            deliveryFields: finalReplyDeliveryFields,
+                            kind: finalResponseText !== null ? deliveryOutcome.kind : null,
+                            typingIndicatorDeliveryFields,
+                        });
                 const reactionDeliveryResult = await deliverAssistantProviderReactions({
                     currentInput,
                     providerResult,
@@ -1210,16 +1399,22 @@ export async function sendAssistantMessageLocal(input) {
                     : deliveryOutcome;
                 emitTurnTiming({
                     deliveryAttempted: finalResponseText !== null || reactionDeliveryOutcomes.length > 0,
+                    deliveryIntentId: 'intentId' in finalDeliveryOutcome
+                        ? finalDeliveryOutcome.intentId
+                        : null,
                     deliveryIntentPresent: 'intentId' in finalDeliveryOutcome
                         ? finalDeliveryOutcome.intentId !== null
                         : false,
                     deliveryOutcomeKind: finalDeliveryOutcome.kind,
                     elapsedMs: elapsedSince(turnTimingStartedAt),
                     finalReplySelected: finalResponseText !== null,
+                    providerRequestElapsedMs: providerRequestStartedAtMs === null || providerResultReturnedAt === null
+                        ? null
+                        : Math.max(0, providerResultReturnedAt - providerRequestStartedAtMs),
                     providerRequestOrdinal,
-                    sinceProviderResultMs: providerResultReturnedAt === null
+                    sinceProviderResultMs: providerResultReturnedAt === null || replyIntentReadyAt === null
                         ? null
-                        : elapsedSince(providerResultReturnedAt),
+                        : Math.max(0, replyIntentReadyAt - providerResultReturnedAt),
                     stage: 'reply-dispatched',
                     stepElapsedMs: elapsedSince(replyDispatchStartedAt),
                 });
@@ -1306,7 +1501,9 @@ export async function sendAssistantMessageLocal(input) {
             }
             finally {
                 activeTurnInputController?.close();
-                await stopAssistantChannelTypingIndicator(typingIndicator);
+                await stopAssistantChannelTypingIndicator(typingIndicator, {
+                    providerStop: !deliverySupersededTypingIndicator,
+                });
                 if (!(executionContext?.hosted != null
                     && input.deliveryDispatchMode === 'queue-only'
                     && input.turnTrigger === 'automation-auto-reply')) {
@@ -1315,6 +1512,44 @@ export async function sendAssistantMessageLocal(input) {
             }
         },
     });
+    try {
+        return await runLockedTurn();
+    }
+    finally {
+        // The automation pass owns maintenance for auto-reply turns; every
+        // independently-started turn keeps a post-turn owner so direct ask/chat/
+        // assistantd use cannot grow runtime state (transcripts, event logs)
+        // without bound. Post-turn keeps it off the foreground reply path.
+        if (input.turnTrigger !== 'automation-auto-reply') {
+            await runAssistantTurnBestEffort(() => maybeRunAssistantRuntimeMaintenance({
+                signal: input.abortSignal ?? null,
+                vault: input.vault,
+            }));
+        }
+    }
+}
+function assistantDeliveryOutcomeSupersedesTypingIndicatorForTarget(input) {
+    if (!assistantDeliveryOutcomeSupersedesTypingIndicator(input.kind)) {
+        return false;
+    }
+    if (!input.typingIndicatorDeliveryFields || !input.deliveryFields) {
+        return true;
+    }
+    const typingChannel = normalizeAssistantDeliveryMatchChannel(input.typingIndicatorDeliveryFields.channel);
+    const deliveryChannel = normalizeAssistantDeliveryMatchChannel(input.deliveryFields.channel);
+    if (typingChannel && deliveryChannel && typingChannel !== deliveryChannel) {
+        return false;
+    }
+    const typingTarget = resolveAssistantVaultFileSendTargetFingerprint(input.typingIndicatorDeliveryFields);
+    const deliveryTarget = resolveAssistantVaultFileSendTargetFingerprint(input.deliveryFields);
+    if (!typingTarget || !deliveryTarget) {
+        return true;
+    }
+    return typingTarget === deliveryTarget;
+}
+function normalizeAssistantDeliveryMatchChannel(value) {
+    const normalized = value?.trim().toLowerCase() ?? '';
+    return normalized.length > 0 ? normalized : null;
 }
 export async function updateAssistantSessionOptionsLocal(input) {
     const session = await resolveAssistantSession({
@@ -1336,7 +1571,13 @@ export async function updateAssistantSessionOptionsLocal(input) {
     const nextProviderOptions = serializeAssistantProviderSessionOptions(providerConfig);
     const continuityChanged = session.session.providerOptions.continuityFingerprint !==
         nextProviderOptions.continuityFingerprint;
-    const currentResumeState = readAssistantCodexResume(session.session);
+    const currentResumeState = bindAssistantResumeStateToThreadCompatibility({
+        resumeState: readAssistantCodexResume(session.session),
+        route: resolveAssistantExecutionPlan({
+            defaults: null,
+            sessionTarget: session.session.target,
+        }).codexRoute,
+    });
     return saveAssistantSession(input.vault, {
         ...session.session,
         codexResume: continuityChanged ? null : currentResumeState,
@@ -1367,26 +1608,6 @@ async function runAssistantTurnBestEffort(task) {
         // Preserve the original turn failure; these cleanup writes are best-effort.
     }
 }
-async function clearAssistantSessionCodexResumeStateIfNeeded(input) {
-    if (input.action !== 'clear') {
-        return input.session;
-    }
-    return await clearAssistantSessionCodexResumeState({
-        session: input.session,
-        vault: input.vault,
-    });
-}
-function resolveProviderResumeStateAction(input) {
-    if (input.threadScope === 'isolated-thread') {
-        return 'preserve-existing';
-    }
-    if (input.codexThreadHistoryUnsafe) {
-        return 'clear';
-    }
-    return normalizeNullableString(input.codexThreadId)
-        ? 'persist-from-provider-turn'
-        : 'clear';
-}
 function resolveInitialAcceptedTurnInputItems(input) {
     const initialInputs = input.input.acceptedTurnInput?.initialInputs ?? null;
     if (initialInputs && initialInputs.length > 0) {
@@ -1513,12 +1734,6 @@ function resolveAssistantReplyDeliveryContextForSegment(input) {
             invalidDeliveryContextOrdinal: null,
         };
     }
-    if (input.deliveryContextOrdinal === undefined || input.deliveryContextOrdinal === null) {
-        return {
-            context: input.contexts[0] ?? null,
-            invalidDeliveryContextOrdinal: null,
-        };
-    }
     if (Number.isInteger(input.deliveryContextOrdinal) &&
         input.deliveryContextOrdinal >= 0 &&
         input.deliveryContextOrdinal < input.contexts.length) {