@murphai/murph 1.3.0 → 1.3.1

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

@@ -1,10 +1,12 @@
 import { assistantAskResultSchema, } from '@murphai/operator-config/assistant-cli-contracts';
+import { renderAssistantResponseCardTranscriptText, renderAssistantResponseCardText, } from '@murphai/operator-config/assistant-response-cards';
 import { assistantBackendTargetToProviderConfigInput, createAssistantModelTarget, createDefaultLocalAssistantModelTarget, } from '@murphai/operator-config/assistant-backend';
+import { CAPTURE_LOOKUP_INDEX_PATH, readStoredCaptureLookupIndex, } from '@murphai/core';
 import { appendAssistantTranscriptEntries, appendAssistantTranscriptEntriesWithRefs, redactAssistantDisplayPath, resolveAssistantSession, saveAssistantSession, } from './store.js';
 import { resolveAssistantConversationLookupKey } from './store/paths.js';
 import { resolveAssistantOperatorDefaults } from '@murphai/operator-config/operator-config';
 import { normalizeAssistantDeliveryError, } from './outbox.js';
-import { ASSISTANT_IMAGE_RESPONSE_TRANSCRIPT_MARKER, } from './response-media.js';
+import { ASSISTANT_IMAGE_RESPONSE_TRANSCRIPT_MARKER, resolveAssistantGeneratedImageDelivery, } from './response-media.js';
 import { recordAssistantDiagnosticEvent } from './diagnostics.js';
 import { refreshAssistantStatusSnapshotLocal } from './status.js';
 import { resolveAssistantTurnSharedPlan as buildAssistantTurnSharedPlan, } from './turn-plan.js';
@@ -17,12 +19,11 @@ import { applyAssistantSessionCodexResumeStateAction, clearAssistantSessionCodex
 import { bindAssistantResumeStateToThreadCompatibility, } from './codex-resume-binding.js';
 import { readAssistantCodexResume, } from './conversation-persistence.js';
 import { appendAssistantTurnReceiptEvent, createAssistantTurnReceipt, finalizeAssistantTurnReceipt, } from './turns.js';
-import { mergeAssistantProviderConfigsForProvider, serializeAssistantProviderSessionOptions, } from '@murphai/operator-config/assistant/provider-config';
+import { mergeAssistantProviderConfigs, serializeAssistantProviderSessionOptions, } from '@murphai/operator-config/assistant/provider-config';
 import { VaultCliError } from '@murphai/operator-config/vault-cli-errors';
-import { normalizeAssistantExecutionContext, } from './execution-context.js';
-import { resolveAssistantExecutionDefaultTarget } from './execution-context.js';
-import { resolveAssistantExecutionOperatorDefaults } from './execution-context.js';
+import { normalizeAssistantExecutionContext, resolveAssistantExecutionDefaultTarget, resolveAssistantExecutionOperatorDefaults, } from './execution-context.js';
 import { executeCodexTurnWithRecovery, resolveAssistantCodexThreadScope, } from './codex-turn-runner.js';
+import { stampAssistantProviderStartCriticalPath, } from './provider-start-critical-path.js';
 import { readCodexThreadCompatibilityFingerprint, readCodexThreadRouteFingerprint, } from './codex-thread-route.js';
 import { resolveAssistantExecutionPlan } from './execution-plan.js';
 import { normalizeAssistantAskResultForReturn, serializeAssistantSessionForResult, } from './service-result.js';
@@ -165,6 +166,16 @@ async function persistUserTurn(input, resolved, plan, turnId) {
     };
 }
 const UNVERIFIED_EXTERNAL_AUDIENCE_RESPONSE = "I couldn't verify whether this is a private or group conversation, so I can't safely use account context here yet. Please try again in your private chat with Murph.";
+const UNVERIFIED_EXTERNAL_SUPPORT_CONTACT_RESPONSE = `${UNVERIFIED_EXTERNAL_AUDIENCE_RESPONSE} You can email support@withmurph.ai.`;
+function resolveUnverifiedExternalAudienceResponse(prompt) {
+    const asksForSupportContact = /\bsupport\b/iu.test(prompt)
+        && /\b(?:address|contact|e-?mail|reach)\b/iu.test(prompt)
+        && (/[?]/u.test(prompt)
+            || /\b(?:give|how|need|please|send|share|tell|want|what|where)\b/iu.test(prompt));
+    return asksForSupportContact
+        ? UNVERIFIED_EXTERNAL_SUPPORT_CONTACT_RESPONSE
+        : UNVERIFIED_EXTERNAL_AUDIENCE_RESPONSE;
+}
 async function completeUnverifiedExternalAudienceTurn(input) {
     let turnCreatedAt = input.userTurn.turnCreatedAt;
     if (!input.userTurn.userPersisted) {
@@ -181,7 +192,7 @@ async function completeUnverifiedExternalAudienceTurn(input) {
     await appendAssistantTranscriptEntries(input.message.vault, input.session.sessionId, [{
             createdAt: turnCreatedAt,
             kind: 'assistant',
-            text: UNVERIFIED_EXTERNAL_AUDIENCE_RESPONSE,
+            text: input.response,
         }]);
     const updatedAt = new Date().toISOString();
     const savedSession = await saveAssistantSession(input.message.vault, {
@@ -192,14 +203,14 @@ async function completeUnverifiedExternalAudienceTurn(input) {
     });
     const outcome = await dispatchAssistantReply({
         input: input.message,
-        response: UNVERIFIED_EXTERNAL_AUDIENCE_RESPONSE,
+        response: input.response,
         session: savedSession,
         sharedPlan: input.plan,
         turnId: input.turnId,
     });
     await finalizeDeliveredAssistantTurn({
         outcome,
-        response: UNVERIFIED_EXTERNAL_AUDIENCE_RESPONSE,
+        response: input.response,
         turnId: input.turnId,
         vault: input.message.vault,
     });
@@ -216,7 +227,7 @@ async function completeUnverifiedExternalAudienceTurn(input) {
                 : null,
             media: outcome.media,
             prompt: input.message.prompt,
-            response: UNVERIFIED_EXTERNAL_AUDIENCE_RESPONSE,
+            response: input.response,
             session: outcome.session,
             status: 'completed',
             vault: redactAssistantDisplayPath(input.message.vault),
@@ -228,6 +239,7 @@ export async function openAssistantConversationLocal(input) {
     return resolveAssistantSession(buildResolveAssistantSessionInput(input, defaults, createDefaultLocalAssistantModelTarget()));
 }
 export async function sendAssistantMessageLocal(input) {
+    const providerStartAtAssistantService = stampAssistantProviderStartCriticalPath(input.providerStartCriticalPath, 'assistantServiceStartedAtMonotonicMs');
     await assertAssistantAcceptedTurnInputItemInputsAssistantInputEventsExist({
         inputs: input.acceptedTurnInput?.initialInputs ?? [],
         vault: input.vault,
@@ -254,11 +266,13 @@ export async function sendAssistantMessageLocal(input) {
         defaults: await resolveAssistantOperatorDefaults(),
         executionContext,
     });
+    const providerStartAtTurnLockWait = stampAssistantProviderStartCriticalPath(providerStartAtAssistantService, 'assistantTurnLockWaitStartedAtMonotonicMs');
     const turnLockWaitStartedAt = Date.now();
     const runLockedTurn = () => withAssistantTurnLock({
         abortSignal: input.abortSignal,
         vault: input.vault,
         run: async () => {
+            const providerStartAtTurnLockAcquired = stampAssistantProviderStartCriticalPath(providerStartAtTurnLockWait, 'assistantTurnLockAcquiredAtMonotonicMs');
             const lockAcquiredAt = Date.now();
             const turnLockWaitMs = elapsedSince(turnLockWaitStartedAt);
             emitHostedAssistantContextTimingTrace({
@@ -315,10 +329,11 @@ export async function sendAssistantMessageLocal(input) {
             try {
                 if (resolveAssistantConversationScope(sharedPlan.conversationPolicy.audience) === 'unverified-external') {
                     userTurn = await persistUserTurn(input, resolved, sharedPlan, receipt.turnId);
-                    responseText = UNVERIFIED_EXTERNAL_AUDIENCE_RESPONSE;
+                    responseText = resolveUnverifiedExternalAudienceResponse(input.prompt);
                     const completed = await completeUnverifiedExternalAudienceTurn({
                         message: input,
                         plan: sharedPlan,
+                        response: responseText,
                         session: resolved.session,
                         turnId: receipt.turnId,
                         userTurn,
@@ -327,6 +342,8 @@ export async function sendAssistantMessageLocal(input) {
                         assistantDeliveryOutcomeSupersedesTypingIndicator(completed.outcome.kind);
                     return completed.result;
                 }
+                const runtimeState = createAssistantRuntimeStateService(input.vault);
+                const preProviderSteerAcceptedInputJournals = new Map();
                 const turnInputController = createAssistantActiveTurnInputController({
                     acceptedInputValidator: async ({ acceptedInputs }) => {
                         await assertAssistantAcceptedTurnInputItemInputsAssistantInputEventsExist({
@@ -337,7 +354,21 @@ export async function sendAssistantMessageLocal(input) {
                     admissionHook: input.activeTurnInput,
                     beforeProviderSteer: input.beforeProviderAcceptedInputs
                         ? async (event) => {
-                            await input.beforeProviderAcceptedInputs?.(event);
+                            const acceptedInputJournal = await runtimeState.turns.acceptedInputs.append({
+                                inputs: event.acceptedInputs,
+                                sessionId: resolved.session.sessionId,
+                                turnId: receipt.turnId,
+                            });
+                            await assertAssistantAcceptedTurnInputAssistantInputEventsExist({
+                                journal: acceptedInputJournal,
+                                vault: input.vault,
+                            });
+                            const releaseProviderAcceptedInputs = await input.beforeProviderAcceptedInputs?.({
+                                ...event,
+                                turnId: receipt.turnId,
+                            });
+                            preProviderSteerAcceptedInputJournals.set(JSON.stringify(event.acceptedInputs.map((item) => item.id)), acceptedInputJournal);
+                            return releaseProviderAcceptedInputs;
                         }
                         : undefined,
                     conversationKeys: [
@@ -351,7 +382,6 @@ export async function sendAssistantMessageLocal(input) {
                 activeTurnInputController = turnInputController;
                 userTurn = await persistUserTurn(input, resolved, sharedPlan, receipt.turnId);
                 let currentUserTurn = userTurn;
-                const runtimeState = createAssistantRuntimeStateService(input.vault);
                 const initialAcceptedTurnInputItems = resolveInitialAcceptedTurnInputItems({
                     input,
                     resolved,
@@ -391,7 +421,7 @@ export async function sendAssistantMessageLocal(input) {
                 let acceptedInputIdsForProviderRequest = initialAcceptedInputJournal.inputIds;
                 let acceptedInputItemsForProviderRequest = initialAcceptedInputJournal.inputs;
                 let providerRequestAcceptedInputIds = initialAcceptedInputJournal.inputIds;
-                let beforeHostedToolExecution = async () => { };
+                let beforeHostedToolExecution = async (_throughDeliveryContextOrdinal) => { };
                 const refreshTypingIndicatorAfterProgress = () => {
                     void runAssistantTurnBestEffort(async () => {
                         await typingIndicator?.refreshAfterMessage?.();
@@ -401,10 +431,28 @@ export async function sendAssistantMessageLocal(input) {
                     hostedOptionalProgressDeliveryAvailable
                     ? createAssistantProgressDelivery({
                         deliver: async (progressInput) => {
+                            const deliveryContextOrdinal = progressInput.deliveryContextOrdinal ?? 0;
+                            const { targetInputId, ...untargetedProgressInput } = progressInput;
+                            if (targetInputId) {
+                                await beforeHostedToolExecution(deliveryContextOrdinal);
+                            }
+                            const resolvedProgressInput = targetInputId
+                                ? {
+                                    ...untargetedProgressInput,
+                                    input: await applyAssistantAcceptedMessageTargetToDeliveryInput({
+                                        acceptedInputIds: resolveAcceptedInputIdsThroughDeliveryContextOrdinal(deliveryContextOrdinal),
+                                        action: 'native-reply',
+                                        input: progressInput.input,
+                                        session: progressInput.session,
+                                        sharedPlan,
+                                        targetInputId,
+                                    }),
+                                }
+                                : untargetedProgressInput;
                             const hosted = hostedExecutionContext;
                             if (hosted) {
                                 const dependencies = hosted.progressDeliveryDependencies;
-                                const progressChannel = resolveAssistantProgressDeliveryChannel(progressInput);
+                                const progressChannel = resolveAssistantProgressDeliveryChannel(resolvedProgressInput);
                                 if (!dependencies ||
                                     !hasHostedTextDeliveryForChannel({
                                         channel: progressChannel,
@@ -416,7 +464,7 @@ export async function sendAssistantMessageLocal(input) {
                                     ? dependencies.sendLinq
                                     : undefined;
                                 if (sendLinq) {
-                                    await beforeHostedToolExecution();
+                                    await beforeHostedToolExecution(deliveryContextOrdinal);
                                 }
                                 const progressDependencies = sendLinq
                                     ? {
@@ -430,14 +478,14 @@ export async function sendAssistantMessageLocal(input) {
                                     }
                                     : dependencies;
                                 const result = await deliverAssistantProgressUpdate({
-                                    ...progressInput,
+                                    ...resolvedProgressInput,
                                     dependencies: progressDependencies,
                                 });
                                 refreshTypingIndicatorAfterProgress();
                                 return result;
                             }
                             const result = await deliverAssistantProgressUpdate({
-                                ...progressInput,
+                                ...resolvedProgressInput,
                             });
                             refreshTypingIndicatorAfterProgress();
                             return result;
@@ -474,10 +522,13 @@ export async function sendAssistantMessageLocal(input) {
                     && actionApprovalPort != null
                     && currentDeliveryFields.channel?.trim().toLowerCase() === 'linq'
                     && vaultFileSendTargetFingerprint !== null;
+                const pendingVaultFilesAvailable = input.deliverResponse === true
+                    && currentAudienceReplyDeliveryAvailable
+                    && currentDeliveryFields.channel?.trim().toLowerCase() === 'linq';
                 const hostedToolContext = hostedExecutionContext
                     ? createAssistantHostedToolContext({
                         computerToolsAvailable: hostedComputerToolsAvailable,
-                        beforeToolExecution: () => beforeHostedToolExecution(),
+                        beforeToolExecution: (deliveryContextOrdinal) => beforeHostedToolExecution(deliveryContextOrdinal),
                         executionContext: hostedExecutionContext,
                         getDeliveryContext: () => ({
                             messageInput: currentInput,
@@ -490,10 +541,47 @@ export async function sendAssistantMessageLocal(input) {
                         }),
                         getProductFeedbackAcceptedInputIds: () => resolveAssistantProductFeedbackAcceptedInputIds(acceptedInputItemsForProviderRequest),
                         messageInput: input,
+                        pendingVaultFilesAvailable,
+                        verifyGeneratedImageDelivery: async (candidate) => {
+                            try {
+                                const imageRef = candidate.imageRef;
+                                const knownFromCurrentCompletion = currentInput.hostedImageCompletionEffectRestriction
+                                    ?.exactMedia?.some((media) => media.ref === imageRef) === true;
+                                const [intents, transcriptEntries, captureLookupIndex] = await Promise.all([
+                                    runtimeState.outbox.listIntents(),
+                                    runtimeState.transcripts.list(currentSession.sessionId),
+                                    (async () => {
+                                        await hostedExecutionContext
+                                            ?.materializeWorkspaceArtifacts?.([
+                                            CAPTURE_LOOKUP_INDEX_PATH,
+                                        ]);
+                                        return await readStoredCaptureLookupIndex({
+                                            vaultRoot: input.vault,
+                                        });
+                                    })(),
+                                ]);
+                                return resolveAssistantGeneratedImageDelivery({
+                                    currentMedia: {
+                                        contentType: candidate.contentType,
+                                        sha256: candidate.sha256,
+                                        sizeBytes: candidate.sizeBytes,
+                                    },
+                                    generatedImageOriginKnown: knownFromCurrentCompletion ||
+                                        Object.values(captureLookupIndex.entries).some((entry) => entry.attachmentRef === imageRef),
+                                    imageRef,
+                                    intents,
+                                    sessionId: currentSession.sessionId,
+                                    transcriptEntries,
+                                });
+                            }
+                            catch {
+                                return false;
+                            }
+                        },
                         route,
                         ...(vaultFileSendAvailable && actionApprovalPort
                             ? {
-                                sendVaultFile: async (ref, toolCallId) => {
+                                sendVaultFile: async (ref, toolCallId, retireExportPackIds) => {
                                     const deliveryFields = resolveAssistantCurrentAudienceDeliveryFields({
                                         input: currentInput,
                                         session: currentSession,
@@ -523,6 +611,7 @@ export async function sendAssistantMessageLocal(input) {
                                         explicitTarget: deliveryFields.explicitTarget,
                                         identityId: deliveryFields.identityId,
                                         ref,
+                                        retireExportPackIds,
                                         replyToMessageId: deliveryFields.replyToMessageId,
                                         sessionId: currentSession.sessionId,
                                         threadId: deliveryFields.threadId,
@@ -607,15 +696,21 @@ export async function sendAssistantMessageLocal(input) {
                         acceptedInput: acceptanceInput.activeTurnInput,
                         input: currentInput,
                     });
-                    assertAcceptedActiveTurnInputItemsAreNew({
-                        acceptedInputIds: acceptanceInput.providerRequestAcceptedInputIds,
-                        inputs: acceptedInputItems,
-                    });
-                    let acceptedInputJournal = await runtimeState.turns.acceptedInputs.append({
-                        inputs: acceptedInputItems,
-                        sessionId: resolved.session.sessionId,
-                        turnId: currentUserTurn.turnId,
-                    });
+                    const preProviderSteerJournalKey = JSON.stringify(acceptedInputItems.map((item) => item.id));
+                    const preProviderSteerJournal = preProviderSteerAcceptedInputJournals.get(preProviderSteerJournalKey);
+                    if (!preProviderSteerJournal) {
+                        assertAcceptedActiveTurnInputItemsAreNew({
+                            acceptedInputIds: acceptanceInput.providerRequestAcceptedInputIds,
+                            inputs: acceptedInputItems,
+                        });
+                    }
+                    let acceptedInputJournal = preProviderSteerJournal ??
+                        await runtimeState.turns.acceptedInputs.append({
+                            inputs: acceptedInputItems,
+                            sessionId: resolved.session.sessionId,
+                            turnId: currentUserTurn.turnId,
+                        });
+                    preProviderSteerAcceptedInputJournals.delete(preProviderSteerJournalKey);
                     await assertAssistantAcceptedTurnInputAssistantInputEventsExist({
                         journal: acceptedInputJournal,
                         vault: currentInput.vault,
@@ -751,6 +846,7 @@ export async function sendAssistantMessageLocal(input) {
                 // effects may reference any input already admitted into the provider
                 // turn. Native replies and reactions remain exact to one ordinal.
                 const admissionMs = elapsedSince(admissionStartedAt);
+                const providerStartAtPreProviderSetupDone = stampAssistantProviderStartCriticalPath(providerStartAtTurnLockAcquired, 'preProviderSetupDoneAtMonotonicMs');
                 const preProviderSetupMs = elapsedSince(lockAcquiredAt);
                 emitHostedAssistantContextTimingTrace({
                     message: input,
@@ -773,54 +869,64 @@ export async function sendAssistantMessageLocal(input) {
                         ...timingInput,
                     });
                 };
-                const drainLiveSteeredActiveTurnInputs = async (drainInput) => {
-                    while (true) {
-                        if (typeof drainInput.throughDeliveryContextOrdinal === 'number' &&
-                            replyDeliveryContexts.length > drainInput.throughDeliveryContextOrdinal) {
-                            break;
-                        }
-                        const activeTurnInput = await turnInputController.admitLiveSteered();
-                        if (activeTurnInput?.kind !== 'accepted') {
-                            break;
-                        }
-                        const accepted = await acceptActiveTurnInput({
-                            activeTurnInput,
-                            providerRequestAcceptedInputIds,
-                            providerRequestOrdinal,
-                            sessionId: drainInput.sessionId,
-                        });
-                        replyDeliveryContexts.push(pickAssistantReplyDeliveryContext(currentInput));
-                        acceptedInputIdsByDeliveryContextOrdinal[replyDeliveryContexts.length - 1] = accepted.acceptedInputItems.map((item) => item.id);
-                        if (drainInput.continuation) {
-                            providerRequestJournal =
-                                await runtimeState.turns.acceptedInputs.updateProviderRequest({
-                                    acceptedInputIds: accepted.acceptedInputJournal.inputIds,
-                                    continuation: drainInput.continuation,
-                                    ordinal: providerRequestOrdinal,
-                                    providerAttemptId: null,
-                                    turnId: currentUserTurn.turnId,
-                                }) ?? providerRequestJournal;
-                            providerRequestAcceptedInputIds =
-                                providerRequestJournal?.inputIds ??
+                let liveSteeredActiveTurnInputDrainTail = Promise.resolve();
+                const drainLiveSteeredActiveTurnInputs = (drainInput) => {
+                    const drain = liveSteeredActiveTurnInputDrainTail.then(async () => {
+                        while (true) {
+                            if (typeof drainInput.throughDeliveryContextOrdinal === 'number' &&
+                                replyDeliveryContexts.length >
+                                    drainInput.throughDeliveryContextOrdinal) {
+                                break;
+                            }
+                            const activeTurnInput = await turnInputController.admitLiveSteered();
+                            if (activeTurnInput?.kind !== 'accepted') {
+                                break;
+                            }
+                            const accepted = await acceptActiveTurnInput({
+                                activeTurnInput,
+                                providerRequestAcceptedInputIds,
+                                providerRequestOrdinal,
+                                sessionId: drainInput.sessionId,
+                            });
+                            replyDeliveryContexts.push(pickAssistantReplyDeliveryContext(currentInput));
+                            acceptedInputIdsByDeliveryContextOrdinal[replyDeliveryContexts.length - 1] = accepted.acceptedInputItems.map((item) => item.id);
+                            if (drainInput.continuation) {
+                                providerRequestJournal =
+                                    await runtimeState.turns.acceptedInputs.updateProviderRequest({
+                                        acceptedInputIds: accepted.acceptedInputJournal.inputIds,
+                                        continuation: drainInput.continuation,
+                                        ordinal: providerRequestOrdinal,
+                                        providerAttemptId: null,
+                                        turnId: currentUserTurn.turnId,
+                                    }) ?? providerRequestJournal;
+                                providerRequestAcceptedInputIds =
+                                    providerRequestJournal?.inputIds ??
+                                        accepted.acceptedInputJournal.inputIds;
+                                providerRequestAcceptedInputItems =
+                                    providerRequestJournal?.inputs ??
+                                        accepted.acceptedInputJournal.inputs;
+                            }
+                            else {
+                                providerRequestAcceptedInputIds =
                                     accepted.acceptedInputJournal.inputIds;
-                            providerRequestAcceptedInputItems =
-                                providerRequestJournal?.inputs ??
+                                providerRequestAcceptedInputItems =
                                     accepted.acceptedInputJournal.inputs;
+                            }
+                            acceptedInputIdsForProviderRequest =
+                                providerRequestAcceptedInputIds;
+                            acceptedInputItemsForProviderRequest =
+                                providerRequestAcceptedInputItems;
+                            turnInputController.commitLiveSteeredLocalAdmission(activeTurnInput);
                         }
-                        else {
-                            providerRequestAcceptedInputIds =
-                                accepted.acceptedInputJournal.inputIds;
-                            providerRequestAcceptedInputItems =
-                                accepted.acceptedInputJournal.inputs;
-                        }
-                        acceptedInputIdsForProviderRequest = providerRequestAcceptedInputIds;
-                        acceptedInputItemsForProviderRequest = providerRequestAcceptedInputItems;
-                    }
+                    });
+                    liveSteeredActiveTurnInputDrainTail = drain.catch(() => undefined);
+                    return drain;
                 };
-                beforeHostedToolExecution = async () => {
+                beforeHostedToolExecution = async (throughDeliveryContextOrdinal) => {
                     await drainLiveSteeredActiveTurnInputs({
                         continuation: providerRequestContinuation,
                         sessionId: currentSession.sessionId,
+                        throughDeliveryContextOrdinal,
                     });
                 };
                 const providerOutcome = await executeCodexTurnWithRecovery({
@@ -872,6 +978,7 @@ export async function sendAssistantMessageLocal(input) {
                         acceptedInputItemsForProviderRequest = providerRequestAcceptedInputItems;
                         return await input.beforeProviderAcceptedInputs?.({
                             acceptedInputs: providerRequestAcceptedInputItems,
+                            turnId: currentUserTurn.turnId,
                         });
                     },
                     onProviderRequestStarted: (event) => {
@@ -899,6 +1006,11 @@ export async function sendAssistantMessageLocal(input) {
                         threadScope,
                     },
                     providerRequestOrdinal,
+                    ...(providerStartAtPreProviderSetupDone
+                        ? {
+                            providerStartCriticalPath: providerStartAtPreProviderSetupDone,
+                        }
+                        : {}),
                     resolvedSession: currentSession,
                     turnCreatedAt: currentUserTurn.turnCreatedAt,
                     progressDelivery,
@@ -971,6 +1083,9 @@ export async function sendAssistantMessageLocal(input) {
                     const usageRecordStartedAt = Date.now();
                     await recordAssistantUsageEvent({
                         executionContext,
+                        ...(providerRequestStartedAtMs === null
+                            ? {}
+                            : { occurredAt: new Date(providerRequestStartedAtMs).toISOString() }),
                         providerRequestAcceptedInputIds,
                         providerRequestOrdinal,
                         providerRequestOutcome: providerOutcome.providerRequestOutcome,
@@ -1039,6 +1154,7 @@ export async function sendAssistantMessageLocal(input) {
                             response: '',
                             responseDeliveryContextOrdinal: recoverableNoReplyDeliveryContextOrdinal,
                             responseMedia: [],
+                            responseCard: null,
                             route: providerOutcome.route,
                             session: failedNoReplySession,
                             stderr: '',
@@ -1174,6 +1290,7 @@ export async function sendAssistantMessageLocal(input) {
                 await drainLiveSteeredActiveTurnInputs({
                     continuation: providerResult.codexContinuation,
                     sessionId: providerResult.session.sessionId,
+                    throughDeliveryContextOrdinal: providerResult.responseDeliveryContextOrdinal,
                 });
                 currentSession = applyAssistantProgressDeliveredSession({
                     progressDeliveredSession: progressDeliveredSessionRef.value,
@@ -1188,6 +1305,9 @@ export async function sendAssistantMessageLocal(input) {
                 const usageRecordStartedAt = Date.now();
                 await recordAssistantUsageEvent({
                     executionContext,
+                    ...(providerRequestStartedAtMs === null
+                        ? {}
+                        : { occurredAt: new Date(providerRequestStartedAtMs).toISOString() }),
                     providerRequestAcceptedInputIds,
                     providerRequestOrdinal,
                     providerResult,
@@ -1259,6 +1379,9 @@ export async function sendAssistantMessageLocal(input) {
                     precedingResponseSegments.push({
                         deliveryContext: resolvedDeliveryContext.context,
                         response: segment.response,
+                        ...(segment.transcriptResponse === undefined
+                            ? {}
+                            : { transcriptResponse: segment.transcriptResponse }),
                         media: segment.media ?? [],
                         ...(segment.targetInputId
                             ? {
@@ -1274,7 +1397,7 @@ export async function sendAssistantMessageLocal(input) {
                             context: segment.deliveryContext ?? null,
                             input: currentInput,
                         }),
-                        rawResponse: segment.response,
+                        rawResponse: segment.transcriptResponse ?? segment.response,
                         session: currentSession,
                         sharedPlan,
                     });
@@ -1307,7 +1430,10 @@ export async function sendAssistantMessageLocal(input) {
                     });
                 const rawTranscriptResponseText = noReplySelected
                     ? null
-                    : providerResult.transcriptResponse;
+                    : providerResult.transcriptResponse ??
+                        (providerResult.responseCard
+                            ? renderAssistantResponseCardTranscriptText(providerResult.responseCard)
+                            : null);
                 const transcriptResponseText = rawTranscriptResponseText === null
                     ? null
                     : resolveAssistantPersistedReplyText({
@@ -1359,9 +1485,8 @@ export async function sendAssistantMessageLocal(input) {
                                 return segmentInput.input;
                             }
                             return await applyAssistantAcceptedMessageTargetToDeliveryInput({
-                                acceptedInputIdsByDeliveryContextOrdinal,
+                                acceptedInputIds: acceptedInputIdsByDeliveryContextOrdinal[deliveryContextOrdinal] ?? [],
                                 action: 'native-reply',
-                                deliveryContextOrdinal,
                                 input: segmentInput.input,
                                 session: segmentInput.session,
                                 sharedPlan,
@@ -1441,9 +1566,8 @@ export async function sendAssistantMessageLocal(input) {
                     try {
                         finalDeliveryInput =
                             await applyAssistantAcceptedMessageTargetToDeliveryInput({
-                                acceptedInputIdsByDeliveryContextOrdinal,
+                                acceptedInputIds: acceptedInputIdsByDeliveryContextOrdinal[providerResult.responseDeliveryContextOrdinal] ?? [],
                                 action: 'native-reply',
-                                deliveryContextOrdinal: providerResult.responseDeliveryContextOrdinal,
                                 input: finalReplyInput,
                                 session: deliverySession,
                                 sharedPlan,
@@ -1465,6 +1589,7 @@ export async function sendAssistantMessageLocal(input) {
                         }
                         : await dispatchAssistantReply({
                             input: finalDeliveryInput,
+                            card: providerResult.responseCard ?? null,
                             media: providerResult.responseMedia ?? [],
                             response: rawFinalResponseText ?? '',
                             session: deliverySession,
@@ -1578,7 +1703,8 @@ export async function sendAssistantMessageLocal(input) {
                 turnInputController.complete(result);
                 const productFeedbackCandidate = providerResult.productFeedbackCandidate ?? null;
                 const productFeedbackCandidateSink = executionContext?.hosted?.productFeedbackCandidateSink ?? null;
-                if (productFeedbackCandidate && productFeedbackCandidateSink) {
+                if (productFeedbackCandidate &&
+                    productFeedbackCandidateSink) {
                     try {
                         productFeedbackCandidateSink.acceptProductFeedbackCandidate(productFeedbackCandidate);
                     }
@@ -1693,15 +1819,12 @@ export async function updateAssistantSessionOptionsLocal(input) {
         },
         createIfMissing: false,
     });
-    const providerConfig = mergeAssistantProviderConfigsForProvider(input.providerOptions.provider, 
+    const providerConfig = mergeAssistantProviderConfigs(
     // Persisted targets carry the full durable provider config. Session
     // providerOptions are a derived runtime projection and omit target-only
     // fields such as the Codex executable path.
     assistantBackendTargetToProviderConfigInput(session.session.target), input.providerOptions);
     const nextTarget = createAssistantModelTarget(providerConfig) ?? session.session.target;
-    if (nextTarget.adapter !== 'codex-cli') {
-        throw new VaultCliError('ASSISTANT_PROVIDER_UNSUPPORTED', 'Assistant sessions only support Codex app-server targets.');
-    }
     const nextProviderOptions = serializeAssistantProviderSessionOptions(providerConfig);
     const continuityChanged = session.session.providerOptions.continuityFingerprint !==
         nextProviderOptions.continuityFingerprint;
@@ -1749,6 +1872,7 @@ function resolveInitialAcceptedTurnInputItems(input) {
     }
     return [
         {
+            acceptedAt: input.userTurn.turnCreatedAt,
             id: resolveDefaultInitialAcceptedTurnInputId({
                 input: input.input,
                 userTurn: input.userTurn,
@@ -1916,6 +2040,10 @@ function elapsedSince(startedAt) {
     return Math.max(0, Date.now() - startedAt);
 }
 function resolveAssistantProviderFinalResponseText(providerResult) {
+    const card = normalizeAssistantProviderResponseCard(providerResult);
+    if (card) {
+        return renderAssistantResponseCardText(card);
+    }
     const response = normalizeNullableString(providerResult.response);
     if (response) {
         return response;
@@ -1925,6 +2053,13 @@ function resolveAssistantProviderFinalResponseText(providerResult) {
     }
     throw new VaultCliError('ASSISTANT_PROVIDER_EMPTY_RESPONSE', 'Assistant provider completed without a final response. Use finish_without_reply for an intentional no-reply turn.');
 }
+function normalizeAssistantProviderResponseCard(providerResult) {
+    const card = providerResult.responseCard ?? null;
+    if (card !== null && (providerResult.responseMedia ?? []).length > 0) {
+        throw new VaultCliError('ASSISTANT_RESPONSE_CARD_MEDIA_CONFLICT', 'A response card cannot be combined with response media.');
+    }
+    return card;
+}
 function resolveAssistantProviderTranscriptText(input) {
     if (input.response === null) {
         return null;
@@ -1972,9 +2107,8 @@ async function deliverAssistantProviderReactions(input) {
         let reactionInput;
         try {
             reactionInput = await applyAssistantAcceptedMessageTargetToDeliveryInput({
-                acceptedInputIdsByDeliveryContextOrdinal: input.acceptedInputIdsByDeliveryContextOrdinal,
+                acceptedInputIds: input.acceptedInputIdsByDeliveryContextOrdinal[reaction.deliveryContextOrdinal] ?? [],
                 action: 'reaction',
-                deliveryContextOrdinal: reaction.deliveryContextOrdinal,
                 input: baseReactionInput,
                 session: deliverySession,
                 sharedPlan: input.sharedPlan,
@@ -2008,9 +2142,8 @@ async function deliverAssistantProviderReactions(input) {
     };
 }
 async function applyAssistantAcceptedMessageTargetToDeliveryInput(input) {
-    const acceptedInputIds = input.acceptedInputIdsByDeliveryContextOrdinal[input.deliveryContextOrdinal];
     const target = await resolveAssistantAcceptedMessageTarget({
-        acceptedInputIds: acceptedInputIds ?? [],
+        acceptedInputIds: input.acceptedInputIds,
         action: input.action,
         messageRef: input.targetInputId,
         route: resolveAssistantCurrentAudienceDeliveryFields({