@murphai/murph 1.2.0 → 1.2.4

package/node_modules/@murphai/assistant-engine/dist/assistant/notification-turn.js

@@ -1,4 +1,5 @@
 import * as z from 'zod';
+import { parseAssistantSessionRecord, } from '@murphai/operator-config/assistant-cli-contracts';
 import { createDefaultLocalAssistantModelTarget } from '@murphai/operator-config/assistant-backend';
 import { resolveAssistantOperatorDefaults } from '@murphai/operator-config/operator-config';
 import { VaultCliError } from '@murphai/operator-config/vault-cli-errors';
@@ -7,21 +8,28 @@ import { normalizeAssistantExecutionContext } from './execution-context.js';
 import { resolveAssistantExecutionDefaultTarget } from './execution-context.js';
 import { resolveAssistantExecutionOperatorDefaults } from './execution-context.js';
 import { resolveAssistantSessionForMessage } from './session-resolution.js';
+import { resolveAssistantSessionTarget } from './session-resolution.js';
 import { resolveAssistantTurnSharedPlan } from './turn-plan.js';
+import { resolveAssistantConversationScope } from './conversation-policy.js';
 import { executeCodexTurnWithRecovery, } from './codex-turn-runner.js';
-import { readCodexThreadRouteFingerprint, } from './codex-thread-route.js';
+import { normalizeCodexEvent } from '../assistant-codex-events.js';
+import { readCodexThreadCompatibilityFingerprint, readCodexThreadRouteFingerprint, } from './codex-thread-route.js';
 import { recordAdditionalAssistantUsageEvents, recordAssistantUsageEvent, } from './service-usage.js';
-import { persistAssistantTurnAndSession, } from './turn-finalizer.js';
+import { applyAssistantSessionCodexResumeStateAction, persistAssistantTurnAndSession, resolveAssistantProviderResumeStateAction, } from './turn-finalizer.js';
 import { resolveAssistantTurnRoute } from './service-turn-routes.js';
 import { createAssistantTurnId } from './turns.js';
 import { normalizeAssistantDeliverySubject, selectedAssistantEmailDeliveryIsThreadReply, } from './channel-adapters.js';
 import { withAssistantTurnLock } from './turn-lock.js';
+import { buildAssistantMaintenanceConversationEvidence } from './maintenance-evidence.js';
 import { dropUnsupportedAssistantResponseMediaForChannel, finalizeAssistantTurnFromDeliveryOutcome, resolveAssistantCurrentAudienceDeliveryFields, resolveAssistantHostedDeliveryIdempotency, } from './delivery-service.js';
 import { normalizeAssistantResponseMediaList } from './response-media.js';
 import { hasAssistantSeenFirstContact, markAssistantFirstContactSeen, resolveAssistantFirstContactStateDocIds, } from './first-contact.js';
 import { emitHostedAssistantContextSessionResolvedTrace, } from './hosted-context-diagnostics.js';
-import { startAssistantChannelTypingIndicator, stopAssistantChannelTypingIndicator, } from './channel-typing.js';
-import { normalizeAssistantDeliveryError } from './outbox.js';
+import { createAssistantHostedToolContext } from './hosted-tool-context.js';
+import { assistantDeliveryOutcomeSupersedesTypingIndicator, startAssistantChannelTypingIndicator, stopAssistantChannelTypingIndicator, } from './channel-typing.js';
+import { markAssistantOutboxIntentMirrorTerminalById, normalizeAssistantDeliveryError, } from './outbox.js';
+import { createAssistantBinding } from './bindings.js';
+import { createAssistantSessionId, resolveAssistantStatePaths, } from './store/paths.js';
 import { normalizeNullableString, normalizeRequiredText, warnAssistantBestEffortFailure, } from './shared.js';
 const assistantNotificationSkipDecisionSchema = z
     .object({
@@ -46,6 +54,16 @@ const ASSISTANT_NOTIFICATION_TURN_PROFILE = {
     threadScope: 'session-thread',
     toolProfile: 'notification-turn',
 };
+const ASSISTANT_NOTIFICATION_MAINTENANCE_TURN_PROFILE = {
+    nativeResumePolicy: 'disabled',
+    promptProfile: 'notification-decision',
+    threadScope: 'isolated-thread',
+    toolProfile: 'maintenance-turn',
+};
+const ASSISTANT_NOTIFICATION_MAINTENANCE_CODEX_CONFIG_OVERRIDES = [
+    'memories.use_memories=false',
+    'memories.generate_memories=false',
+];
 export async function sendAssistantNotificationLocal(input) {
     const executionContext = normalizeAssistantExecutionContext(input.executionContext);
     const boundaryDefaultTarget = resolveAssistantExecutionDefaultTarget({
@@ -56,22 +74,54 @@ export async function sendAssistantNotificationLocal(input) {
         defaults: await resolveAssistantOperatorDefaults(),
         executionContext,
     });
+    // Built before the turn lock so evidence reads never extend the window in
+    // which fresh foreground input waits on lock admission.
+    const maintenanceEvidence = isAssistantNotificationMaintenanceExactSkip(input)
+        ? await buildAssistantMaintenanceConversationEvidence({
+            now: new Date(),
+            vault: input.vault,
+        })
+        : null;
     return withAssistantTurnLock({
         abortSignal: input.abortSignal,
         vault: input.vault,
         run: async () => {
-            const messageInput = buildAssistantNotificationMessageInput(input);
-            const resolved = await resolveAssistantSessionForMessage({
-                boundaryDefaultTarget,
-                defaults,
-                message: messageInput,
-            });
+            const messageInput = buildAssistantNotificationMessageInput(input, maintenanceEvidence);
+            let newsletterSendResult = input.scheduledAutomationAuthority
+                ? {
+                    status: 'unavailable',
+                    unavailableReason: 'newsletter_send_not_observed',
+                }
+                : null;
+            const resolved = isAssistantNotificationMaintenanceExactSkip(input)
+                ? createAssistantMaintenanceNotificationResolvedSession({
+                    boundaryDefaultTarget,
+                    defaults,
+                    message: messageInput,
+                })
+                : await resolveAssistantSessionForMessage({
+                    boundaryDefaultTarget,
+                    defaults,
+                    message: messageInput,
+                });
             await emitHostedAssistantContextSessionResolvedTrace({
                 message: messageInput,
                 resolved,
                 source: 'assistant-notification',
             });
+            const withPostTurnDeliveryExpectations = (result) => newsletterSendResult
+                ? {
+                    ...result,
+                    postTurnDeliveryExpectations: {
+                        ...(result.postTurnDeliveryExpectations ?? {}),
+                        newsletterSendResult,
+                    },
+                }
+                : result;
             const sharedPlan = await resolveAssistantTurnSharedPlan(messageInput, resolved);
+            if (resolveAssistantConversationScope(sharedPlan.conversationPolicy.audience) === 'unverified-external') {
+                throw new VaultCliError('ASSISTANT_AUDIENCE_UNVERIFIED', 'Notification audience could not be verified as direct or group.');
+            }
             const firstContactDocIds = resolveAssistantNotificationFirstContactDocIds({
                 input: messageInput,
                 session: resolved.session,
@@ -83,56 +133,106 @@ export async function sendAssistantNotificationLocal(input) {
                     docIds: firstContactDocIds,
                     vault: input.vault,
                 })) {
-                return {
+                return withPostTurnDeliveryExpectations({
                     decision: {
                         kind: 'skip',
                         privateSummary: 'First-contact notification already accepted for this route.',
                     },
                     response: null,
                     session: resolved.session,
-                };
+                });
             }
             const responsePolicy = input.responsePolicy ?? { kind: 'allow_send_or_skip' };
             if (responsePolicy.kind === 'require_send_exact_text') {
-                return await sendAssistantExactTextNotificationLocal({
+                return withPostTurnDeliveryExpectations(await sendAssistantExactTextNotificationLocal({
                     firstContactDocIds,
                     input,
                     messageInput,
                     responseText: responsePolicy.text,
                     session: resolved.session,
                     sharedPlan,
-                });
+                }));
             }
-            const route = resolveAssistantTurnRoute(messageInput, defaults, resolved);
             const turnId = createAssistantTurnId();
+            const hostedNewsletterTool = executionContext?.hosted?.newsletterTool ?? null;
+            const hostedToolContext = hostedNewsletterTool
+                ? createAssistantHostedToolContext({
+                    newsletterTool: hostedNewsletterTool,
+                    messageInput,
+                    newsletterOutbox: {
+                        turnId,
+                        vault: input.vault,
+                    },
+                    recordNewsletterSendResult: (result) => {
+                        newsletterSendResult = resolveAssistantNotificationNewsletterSendResult({
+                            current: newsletterSendResult ?? null,
+                            next: result.result,
+                        });
+                    },
+                    session: resolved.session,
+                })
+                : null;
+            const route = resolveAssistantTurnRoute(messageInput, defaults, resolved);
             const turnCreatedAt = new Date().toISOString();
             const progressDelivery = null;
-            const typingIndicator = startAssistantChannelTypingIndicator({
-                channelDependencies: executionContext?.hosted?.channelTypingDependencies ?? null,
-                input: messageInput,
-                precedence: 'audience-first',
-                session: resolved.session,
-                sharedPlan,
-            });
+            let committedDeliveryOutcomeKind = null;
+            const typingIndicator = isAssistantNotificationMaintenanceExactSkip(input)
+                ? null
+                : startAssistantChannelTypingIndicator({
+                    channelDependencies: executionContext?.hosted?.channelTypingDependencies ?? null,
+                    input: messageInput,
+                    precedence: 'audience-first',
+                    session: resolved.session,
+                    sharedPlan,
+                });
             try {
+                const notificationProviderRequestStarted = messageInput.onProviderRequestStarted ?? null;
+                const notificationTurnProfile = resolveAssistantNotificationTurnProfile(input);
                 const providerOutcome = await executeCodexTurnWithRecovery({
                     allowFinishWithoutReply: false,
                     input: messageInput,
+                    // Adapt the runner's lean start event to the message-input hook
+                    // shape; notification turns accept no input items.
+                    onProviderRequestStarted: notificationProviderRequestStarted
+                        ? (event) => notificationProviderRequestStarted({
+                            acceptedInputIds: [],
+                            providerRequestOrdinal: event.providerRequestOrdinal ?? 0,
+                            startedAt: event.startedAt,
+                        })
+                        : undefined,
                     plan: sharedPlan,
                     progressDelivery,
-                    profile: ASSISTANT_NOTIFICATION_TURN_PROFILE,
+                    profile: notificationTurnProfile,
                     resolvedSession: resolved.session,
                     route,
                     turnCreatedAt,
                     turnId,
+                    hostedToolContext,
                 });
                 if (providerOutcome.kind === 'failed_terminal') {
+                    const nonReplayableProviderWork = resolveAssistantNotificationProviderNonReplayableWork({
+                        input,
+                        rawEvents: providerOutcome.rawEvents ?? [],
+                    });
+                    const failedSession = await applyAssistantSessionCodexResumeStateAction({
+                        action: resolveAssistantProviderResumeStateAction({
+                            codexThreadId: providerOutcome.codexThreadId,
+                            threadScope: notificationTurnProfile.threadScope,
+                        }),
+                        assistantContractFingerprint: providerOutcome.assistantContractFingerprint,
+                        codexRolloutRelativePath: providerOutcome.codexRolloutRelativePath,
+                        codexThreadId: providerOutcome.codexThreadId,
+                        routeFingerprint: readCodexThreadRouteFingerprint(providerOutcome.route),
+                        threadCompatibilityFingerprint: readCodexThreadCompatibilityFingerprint(providerOutcome.route),
+                        session: providerOutcome.session,
+                        vault: input.vault,
+                    });
                     const failedProviderResult = {
                         attemptCount: providerOutcome.attemptCount,
                         provider: providerOutcome.route.provider,
                         providerOptions: providerOutcome.route.providerOptions,
                         route: providerOutcome.route,
-                        session: providerOutcome.session ?? resolved.session,
+                        session: failedSession,
                         usage: providerOutcome.usage,
                         usageAttribution: providerOutcome.usageAttribution,
                     };
@@ -149,18 +249,26 @@ export async function sendAssistantNotificationLocal(input) {
                         providerResult: failedProviderResult,
                         turnId,
                     });
-                    throw annotateAssistantNotificationError(providerOutcome.error, buildAssistantNotificationObservabilityDetails({
-                        stage: 'provider',
-                        input: messageInput,
-                        route: providerOutcome.route,
-                        session: resolved.session,
-                    }));
+                    throw annotateAssistantNotificationError(providerOutcome.error, {
+                        ...buildAssistantNotificationObservabilityDetails({
+                            stage: 'provider',
+                            input: messageInput,
+                            route: providerOutcome.route,
+                            session: failedSession,
+                        }),
+                        assistantNotificationProviderNonReplayableWork: nonReplayableProviderWork,
+                    });
                 }
                 const providerResult = providerOutcome.providerTurn;
+                const nonReplayableProviderWork = resolveAssistantNotificationProviderNonReplayableWork({
+                    input,
+                    rawEvents: providerResult.rawEvents ?? [],
+                });
                 const selectedRoute = providerResult.route;
-                const providerResumeStateAction = normalizeNullableString(providerResult.codexThreadId)
-                    ? 'persist-from-provider-turn'
-                    : 'preserve-existing';
+                const providerResumeStateAction = resolveAssistantNotificationProviderResumeStateAction({
+                    input,
+                    providerResult,
+                });
                 await recordAssistantUsageEvent({
                     executionContext,
                     providerResult,
@@ -173,9 +281,45 @@ export async function sendAssistantNotificationLocal(input) {
                     providerResult,
                     turnId,
                 });
-                const decision = parseAssistantNotificationDecision(providerResult.response);
+                const providerValidationErrorDetails = {
+                    ...buildAssistantNotificationObservabilityDetails({
+                        stage: 'provider',
+                        input: messageInput,
+                        route: selectedRoute,
+                        session: providerResult.session,
+                    }),
+                    assistantNotificationProviderNonReplayableWork: nonReplayableProviderWork,
+                };
+                let decision;
+                try {
+                    decision = parseAssistantNotificationDecision(providerResult.response);
+                }
+                catch (error) {
+                    throw annotateAssistantNotificationError(error, providerValidationErrorDetails);
+                }
+                if (isAssistantNotificationMaintenanceExactSkip(input)) {
+                    try {
+                        assertAssistantMaintenanceNotificationDecision({
+                            decision,
+                            policy: input.turnPolicy,
+                        });
+                    }
+                    catch (error) {
+                        throw annotateAssistantNotificationError(error, providerValidationErrorDetails);
+                    }
+                    return withPostTurnDeliveryExpectations({
+                        decision,
+                        response: null,
+                        session: resolved.session,
+                    });
+                }
                 if (decision.kind === 'skip') {
                     assertAssistantNotificationSkipAllowed(responsePolicy);
+                    await runAssistantNotificationBeforeCommit(input, {
+                        decision,
+                        deliveryOutcome: null,
+                        response: null,
+                    });
                     const savedSession = await persistAssistantTurnAndSession({
                         assistantTranscriptText: null,
                         input: messageInput,
@@ -187,60 +331,167 @@ export async function sendAssistantNotificationLocal(input) {
                         turnCreatedAt,
                         turnId,
                     });
-                    return {
+                    return withPostTurnDeliveryExpectations({
                         decision,
                         response: null,
                         session: savedSession,
-                    };
+                    });
                 }
                 const responseText = normalizeRequiredText(decision.text, 'notification response');
+                throwIfAssistantNotificationAborted(messageInput.abortSignal);
                 const state = createAssistantRuntimeStateService(input.vault);
-                await state.turns.createReceipt({
-                    sessionId: providerResult.session.sessionId,
-                    provider: selectedRoute.provider,
-                    providerModel: selectedRoute.providerOptions.model
-                        ?? providerResult.session.providerOptions.model
-                        ?? null,
-                    prompt: messageInput.prompt,
-                    deliveryRequested: true,
-                    turnId,
-                });
-                const savedSession = await persistAssistantTurnAndSession({
-                    assistantTranscriptText: responseText,
-                    input: messageInput,
-                    plan: sharedPlan,
-                    persistUserPromptToTranscript: false,
-                    providerResult,
-                    providerResumeStateAction,
-                    session: providerResult.session,
-                    turnCreatedAt,
-                    turnId,
-                });
+                const createNotificationReceipt = async (session) => {
+                    await state.turns.createReceipt({
+                        sessionId: session.sessionId,
+                        provider: selectedRoute.provider,
+                        providerModel: selectedRoute.providerOptions.model
+                            ?? session.providerOptions.model
+                            ?? null,
+                        prompt: messageInput.prompt,
+                        deliveryRequested: true,
+                        turnId,
+                    });
+                };
+                if (input.deferCommitUntilDeliveryAccepted !== true) {
+                    await createNotificationReceipt(providerResult.session);
+                    const savedSession = await persistAssistantTurnAndSession({
+                        assistantTranscriptText: responseText,
+                        input: messageInput,
+                        plan: sharedPlan,
+                        persistUserPromptToTranscript: false,
+                        providerResult,
+                        providerResumeStateAction,
+                        session: providerResult.session,
+                        turnCreatedAt,
+                        turnId,
+                    });
+                    const deliveryOutcome = await deliverAssistantNotificationMessage({
+                        dedupeToken: input.deliveryDedupeToken ?? null,
+                        decisionSubject: decision.subject ?? null,
+                        input: messageInput,
+                        media: providerResult.responseMedia ?? [],
+                        message: responseText,
+                        session: savedSession,
+                        sharedPlan,
+                        turnId,
+                    });
+                    committedDeliveryOutcomeKind = deliveryOutcome.kind;
+                    await finalizeAssistantTurnFromDeliveryOutcome({
+                        outcome: deliveryOutcome,
+                        response: responseText,
+                        turnId,
+                        vault: input.vault,
+                    });
+                    if (input.firstContactPolicy?.markSeenOnDeliveryAccepted === true &&
+                        assistantNotificationDeliveryAcceptedFirstContact({
+                            deliveryOutcome,
+                            dispatchMode: input.deliveryDispatchMode,
+                        })) {
+                        await markAssistantFirstContactSeen({
+                            docIds: resolveAssistantNotificationFirstContactDocIds({
+                                input: messageInput,
+                                session: deliveryOutcome.session,
+                                sharedPlan,
+                            }),
+                            seenAt: new Date().toISOString(),
+                            vault: input.vault,
+                        });
+                    }
+                    await state.status.refreshSnapshot().catch((error) => {
+                        warnAssistantBestEffortFailure({
+                            error,
+                            operation: 'status snapshot refresh',
+                        });
+                    });
+                    if (deliveryOutcome.kind === 'failed') {
+                        throw annotateAssistantNotificationError(deliveryOutcome.error, buildAssistantNotificationObservabilityDetails({
+                            stage: 'delivery',
+                            input: messageInput,
+                            route: selectedRoute,
+                            session: savedSession,
+                        }));
+                    }
+                    return withPostTurnDeliveryExpectations({
+                        decision: {
+                            ...decision,
+                            text: responseText,
+                        },
+                        deliveryOutcome,
+                        response: responseText,
+                        session: deliveryOutcome.session,
+                    });
+                }
                 const deliveryOutcome = await deliverAssistantNotificationMessage({
                     dedupeToken: input.deliveryDedupeToken ?? null,
                     decisionSubject: decision.subject ?? null,
                     input: messageInput,
                     media: providerResult.responseMedia ?? [],
                     message: responseText,
-                    session: savedSession,
+                    session: providerResult.session,
                     sharedPlan,
                     turnId,
                 });
-                await finalizeAssistantTurnFromDeliveryOutcome({
-                    outcome: deliveryOutcome,
-                    response: responseText,
-                    turnId,
-                    vault: input.vault,
-                });
+                const committedDeliveryOutcome = await (async () => {
+                    try {
+                        await runAssistantNotificationBeforeCommit(input, {
+                            decision: {
+                                ...decision,
+                                text: responseText,
+                            },
+                            deliveryOutcome,
+                            response: responseText,
+                        });
+                        if (deliveryOutcome.kind === 'failed') {
+                            throw annotateAssistantNotificationError(deliveryOutcome.error, buildAssistantNotificationObservabilityDetails({
+                                stage: 'delivery',
+                                input: messageInput,
+                                route: selectedRoute,
+                                session: providerResult.session,
+                            }));
+                        }
+                        await createNotificationReceipt(deliveryOutcome.session);
+                        const savedSession = await persistAssistantTurnAndSession({
+                            assistantTranscriptText: responseText,
+                            input: messageInput,
+                            plan: sharedPlan,
+                            persistUserPromptToTranscript: false,
+                            providerResult,
+                            providerResumeStateAction,
+                            session: deliveryOutcome.session,
+                            turnCreatedAt,
+                            turnId,
+                        });
+                        const finalizedDeliveryOutcome = {
+                            ...deliveryOutcome,
+                            session: savedSession,
+                        };
+                        await finalizeAssistantTurnFromDeliveryOutcome({
+                            outcome: finalizedDeliveryOutcome,
+                            response: responseText,
+                            turnId,
+                            vault: input.vault,
+                        });
+                        return finalizedDeliveryOutcome;
+                    }
+                    catch (error) {
+                        await abandonQueuedNotificationDeliveryAfterCommitFailure({
+                            deliveryOutcome,
+                            error,
+                            vault: input.vault,
+                        });
+                        throw error;
+                    }
+                })();
+                committedDeliveryOutcomeKind = committedDeliveryOutcome.kind;
                 if (input.firstContactPolicy?.markSeenOnDeliveryAccepted === true &&
                     assistantNotificationDeliveryAcceptedFirstContact({
-                        deliveryOutcome,
+                        deliveryOutcome: committedDeliveryOutcome,
                         dispatchMode: input.deliveryDispatchMode,
                     })) {
                     await markAssistantFirstContactSeen({
                         docIds: resolveAssistantNotificationFirstContactDocIds({
                             input: messageInput,
-                            session: deliveryOutcome.session,
+                            session: committedDeliveryOutcome.session,
                             sharedPlan,
                         }),
                         seenAt: new Date().toISOString(),
@@ -253,26 +504,20 @@ export async function sendAssistantNotificationLocal(input) {
                         operation: 'status snapshot refresh',
                     });
                 });
-                if (deliveryOutcome.kind === 'failed') {
-                    throw annotateAssistantNotificationError(deliveryOutcome.error, buildAssistantNotificationObservabilityDetails({
-                        stage: 'delivery',
-                        input: messageInput,
-                        route: selectedRoute,
-                        session: savedSession,
-                    }));
-                }
-                return {
+                return withPostTurnDeliveryExpectations({
                     decision: {
                         ...decision,
                         text: responseText,
                     },
-                    deliveryOutcome,
+                    deliveryOutcome: committedDeliveryOutcome,
                     response: responseText,
-                    session: deliveryOutcome.session,
-                };
+                    session: committedDeliveryOutcome.session,
+                });
             }
             finally {
-                await stopAssistantChannelTypingIndicator(typingIndicator);
+                await stopAssistantChannelTypingIndicator(typingIndicator, {
+                    providerStop: !assistantDeliveryOutcomeSupersedesTypingIndicator(committedDeliveryOutcomeKind),
+                });
             }
         },
     });
@@ -282,18 +527,24 @@ async function sendAssistantExactTextNotificationLocal(input) {
     const turnId = createAssistantTurnId();
     const turnCreatedAt = new Date().toISOString();
     const state = createAssistantRuntimeStateService(input.input.vault);
-    await state.turns.createReceipt({
-        deliveryRequested: true,
-        metadata: {
-            notificationMode: 'deterministic-exact-text',
-        },
-        prompt: input.messageInput.prompt,
-        provider: input.session.provider,
-        providerModel: input.session.providerOptions.model ?? null,
-        sessionId: input.session.sessionId,
-        startedAt: turnCreatedAt,
-        turnId,
-    });
+    throwIfAssistantNotificationAborted(input.input.abortSignal);
+    const createExactTextReceipt = async (session) => {
+        await state.turns.createReceipt({
+            deliveryRequested: true,
+            metadata: {
+                notificationMode: 'deterministic-exact-text',
+            },
+            prompt: input.messageInput.prompt,
+            provider: session.provider,
+            providerModel: session.providerOptions.model ?? null,
+            sessionId: session.sessionId,
+            startedAt: turnCreatedAt,
+            turnId,
+        });
+    };
+    if (input.input.deferCommitUntilDeliveryAccepted !== true) {
+        await createExactTextReceipt(input.session);
+    }
     const deliveryOutcome = await deliverAssistantNotificationMessage({
         dedupeToken: input.input.deliveryDedupeToken ?? null,
         decisionSubject: null,
@@ -304,25 +555,69 @@ async function sendAssistantExactTextNotificationLocal(input) {
         sharedPlan: input.sharedPlan,
         turnId,
     });
-    await finalizeAssistantTurnFromDeliveryOutcome({
-        outcome: deliveryOutcome,
-        response: responseText,
-        turnId,
-        vault: input.input.vault,
-    });
-    if (input.input.deliveryDispatchMode !== 'queue-only' &&
-        deliveryOutcome.kind === 'queued') {
-        throw new VaultCliError('ASSISTANT_NOTIFICATION_DELIVERY_DEFERRED', 'Required exact-text notification delivery was deferred instead of sent.');
+    let savedSession;
+    if (input.input.deferCommitUntilDeliveryAccepted === true) {
+        try {
+            await runAssistantNotificationBeforeCommit(input.input, {
+                decision: {
+                    kind: 'send_message',
+                    privateSummary: 'Sent required exact notification text.',
+                    text: responseText,
+                },
+                deliveryOutcome,
+                response: responseText,
+            });
+            if (input.input.deliveryDispatchMode !== 'queue-only' &&
+                deliveryOutcome.kind === 'queued') {
+                throw new VaultCliError('ASSISTANT_NOTIFICATION_DELIVERY_DEFERRED', 'Required exact-text notification delivery was deferred instead of sent.');
+            }
+            if (deliveryOutcome.kind === 'failed') {
+                throw deliveryOutcome.error;
+            }
+            await createExactTextReceipt(deliveryOutcome.session);
+            await finalizeAssistantTurnFromDeliveryOutcome({
+                outcome: deliveryOutcome,
+                response: responseText,
+                turnId,
+                vault: input.input.vault,
+            });
+            savedSession = await persistAssistantExactTextNotificationSession({
+                responseText,
+                session: deliveryOutcome.session,
+                turnCreatedAt,
+                vault: input.input.vault,
+            });
+        }
+        catch (error) {
+            await abandonQueuedNotificationDeliveryAfterCommitFailure({
+                deliveryOutcome,
+                error,
+                vault: input.input.vault,
+            });
+            throw error;
+        }
     }
-    if (deliveryOutcome.kind === 'failed') {
-        throw deliveryOutcome.error;
+    else {
+        await finalizeAssistantTurnFromDeliveryOutcome({
+            outcome: deliveryOutcome,
+            response: responseText,
+            turnId,
+            vault: input.input.vault,
+        });
+        if (input.input.deliveryDispatchMode !== 'queue-only' &&
+            deliveryOutcome.kind === 'queued') {
+            throw new VaultCliError('ASSISTANT_NOTIFICATION_DELIVERY_DEFERRED', 'Required exact-text notification delivery was deferred instead of sent.');
+        }
+        if (deliveryOutcome.kind === 'failed') {
+            throw deliveryOutcome.error;
+        }
+        savedSession = await persistAssistantExactTextNotificationSession({
+            responseText,
+            session: deliveryOutcome.session,
+            turnCreatedAt,
+            vault: input.input.vault,
+        });
     }
-    const savedSession = await persistAssistantExactTextNotificationSession({
-        responseText,
-        session: deliveryOutcome.session,
-        turnCreatedAt,
-        vault: input.input.vault,
-    });
     if (input.input.firstContactPolicy?.markSeenOnDeliveryAccepted === true &&
         assistantNotificationDeliveryAcceptedFirstContact({
             deliveryOutcome,
@@ -354,6 +649,29 @@ async function sendAssistantExactTextNotificationLocal(input) {
         session: savedSession,
     };
 }
+function resolveAssistantNotificationNewsletterSendResult(input) {
+    if (input.current && input.current.status !== 'unavailable') {
+        return input.current;
+    }
+    return input.next;
+}
+async function runAssistantNotificationBeforeCommit(input, context) {
+    throwIfAssistantNotificationAborted(input.abortSignal);
+    await input.beforeCommit?.(context);
+    throwIfAssistantNotificationAborted(input.abortSignal);
+}
+async function abandonQueuedNotificationDeliveryAfterCommitFailure(input) {
+    if (input.deliveryOutcome.kind !== 'queued') {
+        return;
+    }
+    await markAssistantOutboxIntentMirrorTerminalById({
+        error: input.error,
+        intentId: input.deliveryOutcome.intentId,
+        onlyCurrentStatuses: ['pending', 'retryable', 'awaiting_approval'],
+        status: 'abandoned',
+        vault: input.vault,
+    });
+}
 function assistantNotificationDeliveryAcceptedFirstContact(input) {
     if (input.deliveryOutcome.kind === 'sent') {
         return true;
@@ -383,12 +701,29 @@ function annotateAssistantNotificationError(error, details) {
         annotatedError.details = mergeAssistantNotificationErrorDetails(annotatedError.details, details);
         return annotatedError;
     }
-    const wrapped = new Error(typeof error === 'string' && error.trim().length > 0
-        ? error
-        : 'Assistant notification execution failed.');
+    const deliveryError = normalizeAssistantDeliveryError(error);
+    const wrapped = new Error(deliveryError.message || 'Assistant notification execution failed.');
+    wrapped.code = deliveryError.code ?? null;
+    const retryable = readAssistantNotificationRetryableFlag(error);
+    if (retryable !== null) {
+        wrapped.retryable = retryable;
+    }
     wrapped.details = { ...details };
     return wrapped;
 }
+function readAssistantNotificationRetryableFlag(error) {
+    const record = readAssistantNotificationRecord(error);
+    if (typeof record?.retryable === 'boolean') {
+        return record.retryable;
+    }
+    const context = readAssistantNotificationRecord(record?.context);
+    return typeof context?.retryable === 'boolean' ? context.retryable : null;
+}
+function readAssistantNotificationRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
 function mergeAssistantNotificationErrorDetails(existing, next) {
     return {
         ...(isAssistantNotificationDetailsRecord(existing) ? existing : {}),
@@ -469,8 +804,18 @@ function readAssistantNotificationStringListProperty(value, key) {
     }
     return candidate.filter((entry) => typeof entry === 'string');
 }
-function buildAssistantNotificationMessageInput(input) {
+function buildAssistantNotificationMessageInput(input, maintenanceEvidence) {
+    const instructions = normalizeRequiredText(input.instructions, 'instructions');
+    // One overlay for every maintenance-turn divergence, so the fields cannot
+    // drift apart across separate conditional spreads.
+    const maintenanceOverlay = isAssistantNotificationMaintenanceExactSkip(input)
+        ? {
+            codexConfigOverrides: ASSISTANT_NOTIFICATION_MAINTENANCE_CODEX_CONFIG_OVERRIDES,
+            suppressProviderFailureTranscriptAudit: true,
+        }
+        : {};
     return {
+        ...maintenanceOverlay,
         abortSignal: input.abortSignal,
         actorId: input.actorId,
         alias: input.alias,
@@ -498,22 +843,27 @@ function buildAssistantNotificationMessageInput(input) {
         modelProvider: input.modelProvider,
         oss: input.oss,
         onProviderEvent: input.onProviderEvent ?? null,
+        onProviderRequestStarted: input.onProviderRequestStarted ?? null,
         onTraceEvent: input.onTraceEvent,
         operatorAuthority: input.operatorAuthority,
         participantId: input.participantId,
         persistUserPromptOnFailure: false,
         profile: input.profile,
-        prompt: normalizeRequiredText(input.instructions, 'instructions'),
+        prompt: maintenanceEvidence
+            ? `${instructions}\n\n${maintenanceEvidence}`
+            : instructions,
         provider: input.provider,
         receiptMetadata: null,
         reasoningEffort: input.reasoningEffort,
         sandbox: input.sandbox,
+        scheduledAutomationAuthority: input.scheduledAutomationAuthority ?? null,
         serviceTier: input.serviceTier ?? null,
         sessionId: input.sessionId,
         showThinkingTraces: input.showThinkingTraces,
         threadId: input.threadId,
         threadIsDirect: input.threadIsDirect,
         turnEnvironment: input.turnEnvironment ?? null,
+        assistantTargetOverride: input.assistantTargetOverride ?? null,
         turnTrigger: input.turnTrigger ?? 'automation-cron',
         userMessageContent: null,
         vault: input.vault,
@@ -557,6 +907,7 @@ async function deliverAssistantNotificationMessage(input) {
         dedupeToken: input.dedupeToken,
         deliveryIdempotencyKey: hostedDelivery.deliveryIdempotencyKey,
         deliveryTransportIdempotent: hostedDelivery.deliveryTransportIdempotent,
+        signal: input.input.abortSignal,
         ...deliveryFields,
         media,
         dispatchMode: input.input.deliveryDispatchMode,
@@ -596,6 +947,98 @@ async function deliverAssistantNotificationMessage(input) {
             };
     }
 }
+function resolveAssistantNotificationTurnProfile(input) {
+    return isAssistantNotificationMaintenanceExactSkip(input)
+        ? ASSISTANT_NOTIFICATION_MAINTENANCE_TURN_PROFILE
+        : ASSISTANT_NOTIFICATION_TURN_PROFILE;
+}
+function resolveAssistantNotificationProviderResumeStateAction(input) {
+    if (isAssistantNotificationMaintenanceExactSkip(input.input)) {
+        return 'preserve-existing';
+    }
+    return normalizeNullableString(input.providerResult.codexThreadId)
+        ? 'persist-from-provider-turn'
+        : 'preserve-existing';
+}
+function createAssistantMaintenanceNotificationResolvedSession(input) {
+    const now = new Date().toISOString();
+    const sessionId = createAssistantSessionId();
+    const target = resolveAssistantSessionTarget({
+        boundaryDefaultTarget: input.boundaryDefaultTarget,
+        defaults: input.defaults,
+        input: input.message,
+    });
+    const actorId = input.message.actorId ?? input.message.participantId ?? null;
+    const binding = createAssistantBinding({
+        actorId,
+        channel: input.message.channel,
+        deliveryKind: input.message.deliveryKind,
+        deliveryTarget: input.message.bindingDeliveryTarget ?? input.message.deliveryTarget ?? null,
+        identityId: input.message.identityId,
+        threadId: input.message.threadId,
+        threadIsDirect: input.message.threadIsDirect,
+    });
+    const session = parseAssistantSessionRecord({
+        schema: 'murph.assistant-conversation.v2',
+        conversationId: sessionId,
+        alias: input.message.alias ?? null,
+        binding,
+        codexTarget: target,
+        codexResume: null,
+        createdAt: now,
+        updatedAt: now,
+        lastTurnAt: null,
+        turnCount: 0,
+    });
+    return {
+        created: true,
+        paths: resolveAssistantStatePaths(input.message.vault),
+        session,
+    };
+}
+function isAssistantNotificationMaintenanceExactSkip(input) {
+    return input.turnPolicy?.kind === 'maintenance-exact-skip';
+}
+// Only maintenance turns consume this signal (to decide whether a failed run
+// already performed non-replayable memory writes); it is derived from the
+// committed provider events rather than trusted from provider metadata.
+function resolveAssistantNotificationProviderNonReplayableWork(input) {
+    return isAssistantNotificationMaintenanceExactSkip(input.input) &&
+        assistantMaintenanceRawEventsIncludeMemoryMutation(input.rawEvents);
+}
+function assistantMaintenanceRawEventsIncludeMemoryMutation(rawEvents) {
+    return rawEvents.some((rawEvent) => {
+        const event = normalizeCodexEvent(rawEvent);
+        return (event.kind === 'status_item' &&
+            event.itemType === 'command.execution' &&
+            event.itemState === 'completed' &&
+            event.exitCode === 0 &&
+            isAssistantMaintenanceMemoryMutationCommand(event.commandLabel));
+    });
+}
+function isAssistantMaintenanceMemoryMutationCommand(commandLabel) {
+    const normalized = normalizeNullableString(commandLabel);
+    return (normalized !== null &&
+        /\bvault-cli\b[\s\S]*\bmemory\s+(?:upsert|update)\b/u.test(normalized));
+}
+function assertAssistantMaintenanceNotificationDecision(input) {
+    if (input.policy?.kind === 'maintenance-exact-skip' &&
+        input.decision.kind === 'skip' &&
+        input.decision.privateSummary === input.policy.privateSummary) {
+        return;
+    }
+    throw new VaultCliError('ASSISTANT_NOTIFICATION_MAINTENANCE_DECISION_INVALID', 'Assistant maintenance notification must return the exact configured skip decision.');
+}
+function throwIfAssistantNotificationAborted(signal) {
+    if (!signal?.aborted) {
+        return;
+    }
+    const reason = signal.reason;
+    if (reason instanceof Error) {
+        throw reason;
+    }
+    throw new VaultCliError('ASSISTANT_NOTIFICATION_ABORTED', 'Assistant notification turn was aborted before outbound delivery.');
+}
 function resolveAssistantNotificationFirstContactDocIds(input) {
     const audience = input.sharedPlan.conversationPolicy.audience;
     return resolveAssistantFirstContactStateDocIds({