@murphai/murph 1.2.0 → 1.2.4

package/node_modules/@murphai/assistant-engine/dist/assistant/cron/execution.js

@@ -1,35 +1,51 @@
 import { randomUUID } from 'node:crypto';
 import { setScheduledLogStatus, upsertAutomation } from '@murphai/core';
+import { isHostedRuntimeProcessEnv, } from '@murphai/hosted-execution/cli-runtime-bridge';
 import {} from '@murphai/query';
 import { assistantCronJobSchema, assistantCronRunRecordSchema, } from '@murphai/operator-config/assistant-cli-contracts';
 import { VaultCliError } from '@murphai/operator-config/vault-cli-errors';
-import { sendAssistantNotificationLocal } from '../../assistant-service.js';
+import { sendAssistantNotificationLocal, } from '../../assistant-service.js';
 import { ASSISTANT_REQUIRE_SEND_AUTOMATION_TAG } from '../automation-tags.js';
 import { buildAssistantAutomationTurnEnvelope } from '../automation/turn-envelope.js';
+import { computeAssistantAutomationRetryAt, } from '../automation/shared.js';
+import { MURPH_OVERNIGHT_MEMORY_CONSOLIDATION_AUTOMATION_ID, MURPH_OVERNIGHT_MEMORY_CONSOLIDATION_PRIVATE_SUMMARY, } from '../managed-automations.js';
 import { readAssistantOnboardingState } from '../onboarding-state.js';
 import { runExperimentLifecycleOutcomePrecondition } from '../experiment-support-automations.js';
+import { isAssistantOutboxRetryableError, markAssistantOutboxIntentMirrorTerminalById, } from '../outbox.js';
 import { errorMessage, normalizeNullableString } from '../shared.js';
 import { withAssistantCronWriteLock } from './locking.js';
 import { buildAssistantCronHostedDeliveryIdempotency, buildAssistantCronNotificationDedupeToken, } from './notification-delivery.js';
 import { readAssistantCronCanonicalRuntimeStore, writeAssistantCronCanonicalRuntimeStore, findAssistantCronCanonicalRuntimeRecord, removeAssistantCronCanonicalRuntimeRecord, upsertAssistantCronCanonicalRuntimeRecord, } from './runtime-state.js';
 import { runScheduledLogCronJob } from './scheduled-log.js';
-import { buildAssistantDeviceActivityAuthorityKey, buildAssistantDeviceActivityDeliveryIdempotencyKey, readAssistantDeviceActivityCronJobMetadata, } from '../device-activity-cron-tags.js';
+import { assistantDeviceActivityAuthorityKeyMatches, buildAssistantDeviceActivityDeliveryIdempotencyKey, readAssistantDeviceActivityCronJobMetadata, } from '../device-activity-cron-tags.js';
 import { readAssistantDeviceActivityParentAutomation } from '../device-activity-parent-automation.js';
 import { buildCanonicalAutomationUpsertInput, buildVisibleLocalAssistantCronStore, isCanonicalAssistantCronSourceEnabled, automationContinuityUsesSessionPin, listCanonicalAssistantCronRecords, projectCanonicalAssistantCronJob, resolveCanonicalAssistantCronJobId, resolveCanonicalAssistantCronOccurrenceAt, resolveCanonicalRuntimeState, } from './canonical-jobs.js';
-import { appendAssistantCronRun, isAssistantCronJobDue, readAssistantCronStore, resolveAssistantCronJobIndex, sortAssistantCronJobs, writeAssistantCronStore, } from './store.js';
+import { appendAssistantCronRun, buildAssistantCronTarget, isAssistantCronJobDue, readAssistantCronStore, resolveAssistantCronJobIndex, sortAssistantCronJobs, writeAssistantCronStore, } from './store.js';
 import { resolveAssistantCronFailureBackoffMs, resolveAssistantCronNextRunAfterSuccess, } from './finalization.js';
-import { resolveAssistantCronTargetBindingDelivery, validateAssistantCronDeliveryTarget, } from './targets.js';
+import { resolveAssistantCronNotificationDeliveryRoute, validateAssistantCronDeliveryTarget, } from './targets.js';
 const ASSISTANT_CRON_RUN_SCHEMA = 'murph.assistant-cron-run.v1';
 const ASSISTANT_CRON_MAX_RESPONSE_LENGTH = 4_000;
 const ASSISTANT_CRON_NOTIFICATION_EXPIRES_AFTER_MS = 60 * 60 * 1000;
 const ASSISTANT_CRON_NOTIFICATION_EXPIRED_ERROR = 'Assistant cron notification expired before delivery.';
+const ASSISTANT_CRON_BACKGROUND_MAINTENANCE_YIELD_POLL_MS = 250;
+const ASSISTANT_CRON_BACKGROUND_MAINTENANCE_NON_REPLAYABLE_WORK_ERROR = 'Assistant background maintenance stopped after provider work; occurrence consumed to avoid replay.';
+const ASSISTANT_CRON_FOREGROUND_YIELDED_ERROR = 'Assistant cron yielded to fresh foreground input.';
+const ASSISTANT_CRON_NEWSLETTER_DELIVERY_FAILED_ERROR = 'Group health newsletter delivery did not complete.';
+const GROUP_HEALTH_NEWSLETTER_AUTOMATION_SLUG = 'group-health-newsletter';
+const GROUP_HEALTH_NEWSLETTER_FIRST_SEND_MINIMUM_OPT_OUT_WINDOW_MS = 2 * 60 * 60 * 1000;
 const ASSISTANT_DEVICE_ACTIVITY_AUTHORITY_STALE_ERROR = 'Device activity occurrence skipped because its parent listener is no longer authorized.';
 const ASSISTANT_CRON_ONBOARDING_OPEN_RESEARCH_SKIP_ERROR = 'Assistant cron research-oriented managed automation skipped because assistant onboarding is open.';
 const ASSISTANT_CRON_ONBOARDING_UNREADABLE_RESEARCH_SKIP_ERROR = 'Assistant cron research-oriented managed automation skipped because assistant onboarding state could not be read.';
 const MURPH_RESEARCH_ORIENTED_MANAGED_AUTOMATION_TAGS = new Set([
     'murph-managed:weekly-health-insight',
+    'murph-managed:weekly-improvement-coach',
     'murph-managed:weekly-health-research-scout',
 ]);
+const ASSISTANT_CRON_BACKGROUND_MAINTENANCE_YIELDED_CODE = 'ASSISTANT_CRON_BACKGROUND_MAINTENANCE_YIELDED';
+const ASSISTANT_CRON_BACKGROUND_MAINTENANCE_YIELD_RETRY_MS = 30_000;
+export function computeAssistantCronBackgroundMaintenanceYieldRetryAt(nowIso) {
+    return computeAssistantAutomationRetryAt(ASSISTANT_CRON_BACKGROUND_MAINTENANCE_YIELD_RETRY_MS, Date.parse(nowIso));
+}
 export async function claimResolvedAssistantCronJob(input) {
     if (input.job.kind === 'local') {
         const store = await readAssistantCronStore(input.paths);
@@ -95,7 +111,7 @@ export async function claimResolvedAssistantCronJob(input) {
         }),
     };
 }
-export async function claimNextDueAssistantCronJob(paths, vault) {
+export async function claimNextDueAssistantCronJob(paths, vault, runtimeScopeInput = {}) {
     return withAssistantCronWriteLock(paths, async () => {
         const [store, canonicalRecords, runtimeStore] = await Promise.all([
             readAssistantCronStore(paths),
@@ -107,6 +123,7 @@ export async function claimNextDueAssistantCronJob(paths, vault) {
             canonicalRecords,
             localStore: store,
             nowIso: now,
+            runtimeScopeInput,
             runtimeStore,
         });
         if (!candidate) {
@@ -137,49 +154,188 @@ export async function claimNextDueAssistantCronJob(paths, vault) {
         });
     });
 }
-export async function executeClaimedAssistantCronJob(input) {
-    const claimedJob = input.job.job;
+export function assertAssistantCronJobRunnableInRuntime(input) {
+    if (input.job.kind !== 'canonical' ||
+        canonicalAssistantCronSourceCanRunInRuntime({
+            hostedRuntimeProcess: resolveAssistantCronRuntimeScope(input),
+            source: input.job.source,
+        })) {
+        return;
+    }
+    throw new VaultCliError('ASSISTANT_CRON_RUNTIME_SCOPE_UNAVAILABLE', `Assistant cron job "${input.job.job.name}" is not available in this runtime.`);
+}
+export function buildRunnableAssistantCronJobProjection(input) {
+    const runtimeScopeInput = input.runtimeScopeInput ?? {};
+    const hostedRuntimeProcess = resolveAssistantCronRuntimeScope(runtimeScopeInput);
+    const visibleLocalStore = buildVisibleLocalAssistantCronStore(input.localStore);
+    const canonicalEntries = [];
+    const yieldDeferredBackgroundMaintenanceEntries = [];
+    for (const source of input.canonicalRecords) {
+        if (!canonicalAssistantCronSourceCanRunInRuntime({
+            hostedRuntimeProcess,
+            source,
+        })) {
+            continue;
+        }
+        const runtimeState = resolveCanonicalRuntimeState(source, input.runtimeStore);
+        const entry = {
+            source,
+            runtimeState,
+            runtimeStatePresent: input.runtimeStore.jobs.some((record) => record.jobId === resolveCanonicalAssistantCronJobId(source)),
+            job: projectCanonicalAssistantCronJob({
+                source,
+                runtimeState,
+            }),
+        };
+        // Active foreground yield hides background maintenance from the runnable
+        // set, but the entries stay visible here so status/wake computation can
+        // schedule the catch-up instead of silently disarming a due occurrence.
+        if (canonicalAssistantCronSourceIsBackgroundMaintenance(source) &&
+            runtimeScopeInput.shouldYieldBackgroundMaintenance?.() === true) {
+            yieldDeferredBackgroundMaintenanceEntries.push(entry);
+            continue;
+        }
+        canonicalEntries.push(entry);
+    }
+    return {
+        canonicalEntries,
+        visibleLocalStore,
+        yieldDeferredBackgroundMaintenanceEntries,
+        jobs: sortAssistantCronJobs([
+            ...visibleLocalStore.jobs,
+            ...canonicalEntries.map((entry) => entry.job),
+        ]),
+    };
+}
+export function isAssistantCronBackgroundMaintenanceYieldError(error) {
+    return error instanceof VaultCliError &&
+        error.code === ASSISTANT_CRON_BACKGROUND_MAINTENANCE_YIELDED_CODE;
+}
+export async function executeClaimedAssistantCronJob(rawInput) {
+    const deviceActivityAuthority = await resolveDeviceActivityParentAuthority({
+        job: rawInput.job,
+        vault: rawInput.vault,
+    });
+    const deviceActivityPreparedJob = deviceActivityAuthority.route === null
+        ? rawInput.job
+        : {
+            ...rawInput.job,
+            job: assistantCronJobSchema.parse({
+                ...rawInput.job.job,
+                target: {
+                    ...rawInput.job.job.target,
+                    ...deviceActivityAuthority.route,
+                },
+            }),
+        };
+    // Maintenance has no audience. Neutralize only this ephemeral claim after
+    // authority preparation; the canonical automation route remains unchanged.
+    const preparedJob = assistantCronJobIsPreemptibleBackgroundMaintenance(deviceActivityPreparedJob)
+        ? {
+            ...deviceActivityPreparedJob,
+            job: assistantCronJobSchema.parse({
+                ...deviceActivityPreparedJob.job,
+                target: buildAssistantCronTarget({}),
+            }),
+        }
+        : deviceActivityPreparedJob;
+    const input = {
+        ...rawInput,
+        job: preparedJob,
+    };
+    let claimedJob = input.job.job;
     const startedAt = new Date().toISOString();
     let finishedAt = startedAt;
     let sessionId = null;
     let response = null;
     let errorText = null;
     let errorCode = null;
-    let status = 'failed';
+    let failureConsumesOccurrence = false;
+    let foregroundYielded = false;
+    let outcome = 'failed';
+    let reason = 'unhandled';
     let pendingDeliveryIntentId = null;
+    // Preemptible background maintenance has exactly one yield owner: the
+    // maintenance cancellation below. Wiring the generic foreground poller too
+    // (hosted passes the same predicate as both callbacks) created a race
+    // where whichever poll aborted first decided between a clean maintenance
+    // release and a spurious failed foreground-yield run.
+    const maintenanceJob = assistantCronJobIsPreemptibleBackgroundMaintenance(input.job);
+    let maintenanceProviderStarted = false;
+    const foregroundPreemption = createAssistantCronForegroundPreemption({
+        jobName: claimedJob.name,
+        parentSignal: input.signal,
+        shouldYield: maintenanceJob ? null : input.shouldYield ?? null,
+    });
     const occurrenceAt = input.job.kind === 'canonical'
         ? input.job.runtimeState.state.pendingOccurrenceAt ??
             resolveCanonicalAssistantCronOccurrenceAt(input.job.source, input.job.runtimeState) ??
             startedAt
         : claimedJob.state.nextRunAt ?? startedAt;
+    const yieldCancellation = createAssistantCronBackgroundMaintenanceCancellation({
+        job: input.job,
+        signal: foregroundPreemption.signal ?? null,
+        shouldYieldBackgroundMaintenance: input.shouldYieldBackgroundMaintenance ?? null,
+    });
     try {
-        if (input.signal?.aborted) {
+        if (yieldCancellation.signal.aborted) {
+            if (yieldCancellation.yieldRequested()) {
+                throw createAssistantCronBackgroundMaintenanceYieldError();
+            }
+            if (foregroundPreemption.wasForegroundYielded()) {
+                throw buildAssistantCronForegroundYieldedError(claimedJob.name);
+            }
             throw new VaultCliError('ASSISTANT_CRON_ABORTED', `Assistant cron job "${claimedJob.name}" was aborted before it started.`);
         }
+        if (yieldCancellation.shouldYield()) {
+            throw createAssistantCronBackgroundMaintenanceYieldError();
+        }
         if (input.job.kind === 'canonical') {
             await assertCanonicalRuntimeClaimCurrent({
                 job: input.job,
                 paths: input.paths,
             });
         }
-        const deviceActivityAuthorityError = await resolveDeviceActivityParentAuthorityError({
-            job: input.job,
-            vault: input.vault,
-        });
-        const staleError = input.trigger === 'scheduled'
+        // Lifecycle-owned writes happen before notification expiry so a cleanup
+        // failure remains retryable even when its next attempt crosses the stale
+        // delivery window. Expiry may suppress the outbound, never the owner work.
+        let lifecycleSkipReason = null;
+        if (deviceActivityAuthority.error === null &&
+            input.job.kind === 'canonical' &&
+            input.job.source.kind === 'automation') {
+            // Route on the immutable automationId so a user-edited slug cannot
+            // silently bypass the precondition.
+            const lifecycleResult = await runExperimentLifecycleOutcomePrecondition({
+                automationId: input.job.source.automationId,
+                tags: input.job.source.tags,
+                vault: input.vault,
+            });
+            if (lifecycleResult.kind === 'skip') {
+                lifecycleSkipReason = lifecycleResult.reason;
+            }
+        }
+        const staleError = input.trigger === 'scheduled' &&
+            !assistantCronJobIsPreemptibleBackgroundMaintenance(input.job)
             ? resolveStaleAssistantCronNotificationError({
                 job: claimedJob,
                 nowIso: startedAt,
                 occurrenceAt,
             })
             : null;
-        if (deviceActivityAuthorityError !== null) {
-            status = 'skipped';
-            errorText = deviceActivityAuthorityError;
+        if (deviceActivityAuthority.error !== null) {
+            outcome = 'skipped_gate';
+            reason = 'device_activity_authority_stale';
+            errorText = deviceActivityAuthority.error;
         }
         else if (staleError) {
-            status = 'skipped';
-            errorText = staleError;
+            outcome = 'expired';
+            reason = 'late_occurrence';
+            errorText = staleError.message;
+            emitAssistantCronOccurrenceExpiredEvent({
+                job: input.job,
+                latenessMinutes: staleError.latenessMinutes,
+                onEvent: input.onEvent,
+            });
         }
         else {
             const onboardingSkipError = await resolveResearchOrientedManagedAutomationOnboardingSkipError({
@@ -187,67 +343,111 @@ export async function executeClaimedAssistantCronJob(input) {
                 vault: input.vault,
             });
             if (onboardingSkipError !== null) {
-                status = 'skipped';
+                outcome = 'skipped_gate';
+                reason = onboardingSkipError === ASSISTANT_CRON_ONBOARDING_OPEN_RESEARCH_SKIP_ERROR
+                    ? 'onboarding_open'
+                    : 'onboarding_unreadable';
                 errorText = onboardingSkipError;
             }
             else if (input.job.kind === 'canonical' &&
                 input.job.source.kind === 'scheduledLog') {
+                assertAssistantCronForegroundNotYielded({
+                    jobName: claimedJob.name,
+                    shouldYield: input.shouldYield ?? null,
+                });
                 response = await runScheduledLogCronJob({
                     vault: input.vault,
                     scheduledLogId: input.job.source.scheduledLogId,
                     occurrenceAt,
+                    beforeWrite: async () => {
+                        assertAssistantCronForegroundNotYielded({
+                            jobName: claimedJob.name,
+                            shouldYield: input.shouldYield ?? null,
+                        });
+                    },
+                });
+                assertAssistantCronForegroundNotYielded({
+                    jobName: claimedJob.name,
+                    shouldYield: input.shouldYield ?? null,
                 });
-                status = 'succeeded';
+                outcome = 'no_op';
+                reason = 'scheduled_log';
             }
             else {
-                validateAssistantCronDeliveryTarget(claimedJob.target, assistantCronExecutionDeliveryTargetProfile(input));
+                // Background maintenance never delivers (exact-skip policy), so a
+                // stale or unresolvable route must not block the memory work.
+                if (!assistantCronJobIsPreemptibleBackgroundMaintenance(input.job)) {
+                    validateAssistantCronDeliveryTarget(claimedJob.target, assistantCronExecutionDeliveryTargetProfile(input));
+                }
                 const serviceTier = resolveAssistantCronTurnServiceTier({
                     executionContext: input.executionContext ?? null,
                     job: claimedJob,
                 });
                 const automationTurn = buildAssistantAutomationTurnEnvelope({
+                    assistantTargetOverride: resolveAssistantCronAutomationTargetOverride(input.job) ??
+                        deviceActivityAuthority.assistantTargetOverride,
                     deliveryDispatchMode: input.deliveryDispatchMode,
                     executionContext: input.executionContext,
+                    scheduledAutomationAuthority: resolveAssistantCronScheduledNewsletterAuthority({
+                        job: input.job,
+                        occurrenceAt,
+                        trigger: input.trigger,
+                    }),
                     serviceTier,
-                    signal: input.signal,
+                    signal: yieldCancellation.signal,
                     turnEnvironment: input.turnEnvironment ?? null,
                     turnTrigger: 'automation-cron',
                 });
-                const bindingDelivery = resolveAssistantCronTargetBindingDelivery(claimedJob.target);
-                // Run lifecycle-owned deterministic eligibility + persistence BEFORE
-                // the LLM turn. The precondition reads canonical experiment state
-                // once and decides:
-                //   - `continue`: not a lifecycle job (or eligible and outcome
-                //     persisted); proceed to the LLM as normal.
-                //   - `skip`: ineligible at fire time; mark the run skipped so the
-                //     one-shot is consumed without writing an outcome or invoking
-                //     the LLM.
-                // A persistence failure throws → the surrounding try/catch records
-                // the run as failed and the existing cron backoff retries. We must
-                // not delegate this to the LLM: skip and send_message both mark the
-                // run successful and consume the at-occurrence.
-                let lifecycleSkipReason = null;
-                if (input.job.kind === 'canonical' &&
-                    input.job.source.kind === 'automation') {
-                    // Route on the immutable automationId so a user-edited slug cannot
-                    // silently bypass the precondition.
-                    const lifecycleResult = await runExperimentLifecycleOutcomePrecondition({
-                        automationId: input.job.source.automationId,
-                        tags: input.job.source.tags,
-                        vault: input.vault,
-                    });
-                    if (lifecycleResult.kind === 'skip') {
-                        lifecycleSkipReason = lifecycleResult.reason;
-                    }
-                }
                 if (lifecycleSkipReason !== null) {
-                    status = 'skipped';
+                    outcome = 'skipped_gate';
+                    reason = 'lifecycle_precondition';
                     errorText = lifecycleSkipReason;
                 }
                 else {
+                    if (yieldCancellation.shouldYield()) {
+                        throw createAssistantCronBackgroundMaintenanceYieldError();
+                    }
+                    if (!maintenanceJob) {
+                        assertAssistantCronForegroundNotYielded({
+                            jobName: claimedJob.name,
+                            shouldYield: input.shouldYield ?? null,
+                        });
+                    }
+                    const deliveryRoute = maintenanceJob
+                        ? resolveAssistantCronNotificationDeliveryRoute(claimedJob.target)
+                        : await resolveAssistantCronAuthorizedNotificationDeliveryRoute({
+                            executionContext: input.executionContext ?? null,
+                            signal: yieldCancellation.signal,
+                            target: claimedJob.target,
+                        });
                     const result = await sendAssistantNotificationLocal({
                         vault: input.vault,
                         ...automationTurn,
+                        // Replay barrier: once the provider was admitted, a yielded
+                        // maintenance turn may already have committed memory writes even
+                        // if the completed-command event never reached the buffered raw
+                        // events, so the occurrence must be consumed, not retried.
+                        ...(maintenanceJob
+                            ? {
+                                onProviderRequestStarted: () => {
+                                    maintenanceProviderStarted = true;
+                                },
+                            }
+                            : {}),
+                        beforeCommit: async (context) => {
+                            await preemptAssistantCronNotificationCommitForForeground({
+                                allowTerminalNoDelivery: assistantCronDeviceActivitySkipConsumesOccurrence({
+                                    decision: context.decision,
+                                    deliveryOutcome: context.deliveryOutcome ?? null,
+                                    job: input.job,
+                                }),
+                                deliveryOutcome: context.deliveryOutcome ?? null,
+                                foregroundPreemption,
+                                jobName: claimedJob.name,
+                                shouldYield: input.shouldYield ?? null,
+                                vault: input.vault,
+                            });
+                        },
                         instructions: buildAssistantCronExecutionInstructions(claimedJob),
                         deliveryDedupeToken: buildAssistantCronNotificationDedupeToken({
                             job: claimedJob,
@@ -268,42 +468,136 @@ export async function executeClaimedAssistantCronJob(input) {
                         identityId: claimedJob.target.identityId,
                         onTraceEvent: input.onTraceEvent,
                         participantId: claimedJob.target.participantId,
+                        turnPolicy: resolveAssistantCronNotificationTurnPolicy(input.job),
                         responsePolicy: resolveAssistantCronNotificationResponsePolicy(input.job),
                         threadId: claimedJob.target.threadId,
-                        bindingDeliveryTarget: bindingDelivery?.target ?? undefined,
-                        deliveryKind: bindingDelivery?.kind ?? undefined,
+                        bindingDeliveryTarget: deliveryRoute.bindingDelivery?.target ??
+                            deliveryRoute.deliveryTarget ??
+                            undefined,
+                        deferCommitUntilDeliveryAccepted: input.deliveryDispatchMode === 'queue-only',
+                        deliveryKind: deliveryRoute.bindingDelivery?.kind ?? undefined,
                         deliverySource: claimedJob.target.deliverySource,
-                        deliveryTarget: claimedJob.target.deliveryTarget,
+                        deliveryTarget: deliveryRoute.deliveryTarget,
+                        threadIsDirect: deliveryRoute.threadIsDirect,
                         operatorAuthority: 'direct-operator',
                         workingDirectory: input.vault,
                     });
                     sessionId = result.session.sessionId;
                     response = result.response ?? result.decision.privateSummary;
+                    const postTurnDeliveryFailure = resolveAssistantCronPostTurnDeliveryFailure({
+                        job: input.job,
+                        occurrenceAt,
+                        result,
+                        trigger: input.trigger,
+                    });
+                    if (postTurnDeliveryFailure) {
+                        throw new VaultCliError('ASSISTANT_CRON_NEWSLETTER_SEND_FAILED', postTurnDeliveryFailure);
+                    }
+                    const foregroundYieldedAfterNotification = !maintenanceJob &&
+                        (foregroundPreemption.wasForegroundYielded() ||
+                            input.shouldYield?.() === true);
+                    const deviceActivitySkipConsumedOccurrence = assistantCronDeviceActivitySkipConsumesOccurrence({
+                        decision: result.decision,
+                        deliveryOutcome: result.deliveryOutcome ?? null,
+                        job: input.job,
+                    });
                     if (result.deliveryOutcome?.kind === 'queued') {
                         pendingDeliveryIntentId = result.deliveryOutcome.intentId;
-                        status = 'skipped';
+                        outcome = 'delivery_pending';
+                        reason = 'delivery_pending';
                     }
                     else {
-                        status = 'succeeded';
+                        outcome = result.deliveryOutcome?.kind === 'sent'
+                            ? 'delivered'
+                            : 'no_op';
+                        reason = result.deliveryOutcome?.kind === 'sent'
+                            ? 'sent'
+                            : 'no_delivery';
+                        // Background maintenance success is terminal even when foreground
+                        // input arrived during the turn: the provider work (including any
+                        // memory writes) already happened, so treating it as yielded would
+                        // replay a completed occurrence. Preemption for maintenance only
+                        // applies before or during provider work.
+                        if (foregroundYieldedAfterNotification &&
+                            result.deliveryOutcome?.kind !== 'sent' &&
+                            !deviceActivitySkipConsumedOccurrence) {
+                            throw buildAssistantCronForegroundYieldedError(claimedJob.name);
+                        }
                     }
                 }
             }
         }
     }
     catch (error) {
-        errorText = errorMessage(error);
-        errorCode = error instanceof VaultCliError ? error.code : null;
-        status = 'failed';
+        const backgroundMaintenanceYielded = isAssistantCronBackgroundMaintenanceYieldError(error) ||
+            yieldCancellation.yieldRequested();
+        // Provider admission is the single replay barrier for maintenance: any
+        // terminal failure after admission may have committed memory writes even
+        // when the completed-command event was lost, so the occurrence is
+        // consumed. The overlapping evidence window makes a skipped night safe;
+        // a replay after a committed write is not. The raw-event detector stays
+        // only as a defensive signal for pre-admission edge cases.
+        const nonReplayableBackgroundMaintenanceWork = maintenanceJob &&
+            (maintenanceProviderStarted ||
+                assistantNotificationErrorHasNonReplayableProviderWork(error));
+        if (nonReplayableBackgroundMaintenanceWork) {
+            errorText = ASSISTANT_CRON_BACKGROUND_MAINTENANCE_NON_REPLAYABLE_WORK_ERROR;
+            errorCode = backgroundMaintenanceYielded
+                ? ASSISTANT_CRON_BACKGROUND_MAINTENANCE_YIELDED_CODE
+                : error instanceof VaultCliError ? error.code : null;
+            outcome = 'no_op';
+            reason = 'background_maintenance_non_replayable_work';
+        }
+        else if (backgroundMaintenanceYielded) {
+            if (yieldCancellation.yieldRequested()) {
+                await releaseClaimedAssistantCronJobAfterBackgroundMaintenanceYield({
+                    job: input.job,
+                    paths: input.paths,
+                });
+                throw createAssistantCronBackgroundMaintenanceYieldError();
+            }
+            else {
+                errorText = errorMessage(error);
+                errorCode = error instanceof VaultCliError ? error.code : null;
+                outcome = 'failed';
+                reason = errorCode ?? 'background_maintenance_yield_failed';
+            }
+        }
+        else {
+            const yieldedError = error instanceof AssistantCronForegroundYieldedError ||
+                (foregroundPreemption.wasForegroundYielded() &&
+                    !input.signal?.aborted);
+            if (yieldedError) {
+                foregroundYielded = true;
+                errorText = ASSISTANT_CRON_FOREGROUND_YIELDED_ERROR;
+                errorCode = 'ASSISTANT_CRON_FOREGROUND_YIELDED';
+                reason = 'foreground_yielded';
+            }
+            else {
+                errorText = errorMessage(error);
+                errorCode = readAssistantCronErrorCode(error);
+                failureConsumesOccurrence = assistantCronDeliveryFailureConsumesOccurrence(error);
+                reason = errorCode ?? 'error';
+            }
+            outcome = 'failed';
+        }
     }
     finally {
+        foregroundPreemption.dispose();
         finishedAt = new Date().toISOString();
+        yieldCancellation.dispose();
     }
     const run = assistantCronRunRecordSchema.parse({
         schema: ASSISTANT_CRON_RUN_SCHEMA,
         runId: cryptoRandomRunId(),
         jobId: claimedJob.jobId,
         trigger: input.trigger,
-        status,
+        outcome,
+        reason: normalizeAssistantCronRunReason(reason),
+        status: legacyAssistantCronRunStatusForOutcome({
+            outcome,
+            reason: normalizeAssistantCronRunReason(reason),
+        }),
         startedAt,
         finishedAt,
         sessionId,
@@ -326,15 +620,14 @@ export async function executeClaimedAssistantCronJob(input) {
             const finalizedJob = finalizeAssistantCronJobAfterRun({
                 job: current,
                 finishedAt,
+                foregroundYielded,
+                failureConsumesOccurrence,
                 responseSessionId: sessionId,
                 pendingDeliveryIntentId,
-                run: {
-                    ...run,
-                    status,
-                },
+                run,
             });
             let removedAfterRun = false;
-            if (shouldRemoveAssistantCronJobAfterRun(current, run, pendingDeliveryIntentId)) {
+            if (shouldRemoveAssistantCronJobAfterRun(current, run, pendingDeliveryIntentId, failureConsumesOccurrence)) {
                 store.jobs.splice(index, 1);
                 removedAfterRun = true;
             }
@@ -364,10 +657,9 @@ export async function executeClaimedAssistantCronJob(input) {
         const usesSessionPin = automationContinuityUsesSessionPin(input.job.source);
         const updatedRuntimeState = finalizeCanonicalAssistantCronRuntimeAfterRun({
             finishedAt,
-            run: {
-                ...run,
-                status,
-            },
+            foregroundYielded,
+            failureConsumesOccurrence,
+            run,
             runtimeState: currentRuntimeState,
             responseSessionId: usesSessionPin ? sessionId : null,
             pendingDeliveryIntentId,
@@ -390,7 +682,7 @@ export async function executeClaimedAssistantCronJob(input) {
             runtimeState: persistedRuntimeState,
         });
         let removedAfterRun = false;
-        if (shouldRemoveAssistantCronJobAfterRun(finalizedJob, run, pendingDeliveryIntentId)) {
+        if (shouldRemoveAssistantCronJobAfterRun(finalizedJob, run, pendingDeliveryIntentId, failureConsumesOccurrence)) {
             if (input.job.source.kind === 'automation') {
                 await upsertAutomation(buildCanonicalAutomationUpsertInput({
                     vault: input.vault,
@@ -467,14 +759,66 @@ function resolveAssistantCronTurnServiceTier(input) {
     // tier so the existing 30s failure backoff bounds reminder lateness.
     return input.job.state.consecutiveFailures === 0 ? 'flex' : null;
 }
-function resolveAssistantCronNotificationResponsePolicy(job) {
-    if (readAssistantDeviceActivityCronJobMetadata(job.job.name)) {
-        return { kind: 'require_send' };
+function resolveAssistantCronAutomationTargetOverride(job) {
+    return job.kind === 'canonical' && job.source.kind === 'automation'
+        ? job.source.assistantTargetOverride
+        : null;
+}
+function resolveAssistantCronScheduledNewsletterAuthority(input) {
+    if (input.trigger !== 'scheduled' ||
+        input.job.kind !== 'canonical' ||
+        input.job.source.kind !== 'automation' ||
+        input.job.source.schedule.kind !== 'cron' ||
+        input.job.source.slug !== GROUP_HEALTH_NEWSLETTER_AUTOMATION_SLUG) {
+        return null;
+    }
+    const createdAtMs = Date.parse(input.job.source.createdAt);
+    const occurrenceAtMs = Date.parse(input.occurrenceAt);
+    if (!Number.isFinite(createdAtMs) || !Number.isFinite(occurrenceAtMs)) {
+        return null;
     }
+    if (occurrenceAtMs <
+        createdAtMs + GROUP_HEALTH_NEWSLETTER_FIRST_SEND_MINIMUM_OPT_OUT_WINDOW_MS) {
+        return null;
+    }
+    return {
+        automationId: input.job.source.automationId,
+        occurrenceAt: input.occurrenceAt,
+    };
+}
+function resolveAssistantCronPostTurnDeliveryFailure(input) {
+    if (!resolveAssistantCronScheduledNewsletterAuthority({
+        job: input.job,
+        occurrenceAt: input.occurrenceAt,
+        trigger: input.trigger,
+    })) {
+        return null;
+    }
+    const newsletterSendResult = input.result.postTurnDeliveryExpectations?.newsletterSendResult ?? null;
+    return !newsletterSendResult
+        || newsletterSendResult.status === 'unavailable'
+        || newsletterSendResult.status === 'accepted'
+        ? ASSISTANT_CRON_NEWSLETTER_DELIVERY_FAILED_ERROR
+        : null;
+}
+function resolveAssistantCronNotificationResponsePolicy(job) {
     return listAssistantCronNotificationTags(job).includes(ASSISTANT_REQUIRE_SEND_AUTOMATION_TAG)
         ? { kind: 'require_send' }
         : null;
 }
+function resolveAssistantCronNotificationTurnPolicy(job) {
+    return assistantCronJobIsPreemptibleBackgroundMaintenance(job)
+        ? {
+            kind: 'maintenance-exact-skip',
+            privateSummary: MURPH_OVERNIGHT_MEMORY_CONSOLIDATION_PRIVATE_SUMMARY,
+        }
+        : null;
+}
+function assistantCronDeviceActivitySkipConsumesOccurrence(input) {
+    return (input.decision?.kind === 'skip' &&
+        input.deliveryOutcome === null &&
+        readAssistantDeviceActivityCronJobMetadata(input.job.job.name) !== null);
+}
 function buildAssistantCronDeviceActivityDeliveryIdempotencyKey(input) {
     const metadata = readAssistantDeviceActivityCronJobMetadata(input.job.name);
     const dueAt = normalizeNullableString(input.job.state.nextRunAt);
@@ -502,8 +846,40 @@ function finalizeAssistantCronJobAfterRun(input) {
         lastRunAt: input.finishedAt,
     };
     const shouldAutoBindSession = input.responseSessionId !== null && !assistantCronJobHasStableSessionLocator(input.job);
-    if (assistantCronRunConsumedOccurrence(input.run, input.pendingDeliveryIntentId)) {
+    if (input.foregroundYielded) {
+        return assistantCronJobSchema.parse({
+            ...input.job,
+            updatedAt: input.finishedAt,
+            state: {
+                ...runningClearedState,
+                nextRunAt: computeAssistantCronForegroundYieldRetryAt(input.finishedAt),
+            },
+        });
+    }
+    if (assistantCronRunConsumedOccurrence(input.run, input.pendingDeliveryIntentId, input.failureConsumesOccurrence)) {
         const nextRunAt = resolveAssistantCronNextRunAfterSuccess(input.job, new Date(input.finishedAt));
+        if (input.run.outcome === 'failed') {
+            return assistantCronJobSchema.parse({
+                ...input.job,
+                enabled: input.job.schedule.kind === 'at' && input.job.keepAfterRun
+                    ? false
+                    : input.job.enabled,
+                target: shouldAutoBindSession
+                    ? {
+                        ...input.job.target,
+                        sessionId: input.responseSessionId,
+                    }
+                    : input.job.target,
+                updatedAt: input.finishedAt,
+                state: {
+                    ...runningClearedState,
+                    nextRunAt,
+                    lastFailedAt: input.finishedAt,
+                    lastError: input.run.error,
+                    consecutiveFailures: 0,
+                },
+            });
+        }
         return assistantCronJobSchema.parse({
             ...input.job,
             enabled: input.job.schedule.kind === 'at' && input.job.keepAfterRun
@@ -525,7 +901,7 @@ function finalizeAssistantCronJobAfterRun(input) {
             },
         });
     }
-    if (input.run.status === 'skipped' && input.pendingDeliveryIntentId !== null) {
+    if (input.run.outcome === 'delivery_pending' && input.pendingDeliveryIntentId !== null) {
         return assistantCronJobSchema.parse({
             ...input.job,
             target: shouldAutoBindSession
@@ -559,17 +935,42 @@ function finalizeAssistantCronJobAfterRun(input) {
         },
     });
 }
-function shouldRemoveAssistantCronJobAfterRun(job, run, pendingDeliveryIntentId) {
+function shouldRemoveAssistantCronJobAfterRun(job, run, pendingDeliveryIntentId, failureConsumesOccurrence = false) {
     return (job.schedule.kind === 'at' &&
         !job.keepAfterRun &&
-        assistantCronRunConsumedOccurrence(run, pendingDeliveryIntentId));
+        assistantCronRunConsumedOccurrence(run, pendingDeliveryIntentId, failureConsumesOccurrence));
 }
 // A stale-skipped wake consumes its occurrence like a success so one-shots
 // archive and recurring schedules advance; a delivery-queued skip keeps the
-// occurrence pending until the outbound delivery confirms.
-function assistantCronRunConsumedOccurrence(run, pendingDeliveryIntentId) {
-    return (run.status === 'succeeded' ||
-        (run.status === 'skipped' && pendingDeliveryIntentId === null));
+// occurrence pending until the outbound delivery confirms. Terminal delivery
+// failures also consume the occurrence while remaining failed for observability.
+function assistantCronRunConsumedOccurrence(run, pendingDeliveryIntentId, failureConsumesOccurrence = false) {
+    return (run.outcome === 'delivered' ||
+        run.outcome === 'no_op' ||
+        run.outcome === 'expired' ||
+        run.outcome === 'skipped_gate' ||
+        (failureConsumesOccurrence && run.outcome === 'failed'));
+}
+function assistantCronDeliveryFailureConsumesOccurrence(error) {
+    return assistantCronErrorHasNotificationDeliveryStage(error) &&
+        !isAssistantOutboxRetryableError(error);
+}
+function assistantCronErrorHasNotificationDeliveryStage(error) {
+    const details = readAssistantCronErrorRecord(readAssistantCronErrorRecord(error)?.details);
+    return details?.assistantNotificationStage === 'delivery';
+}
+function readAssistantCronErrorCode(error) {
+    if (error instanceof VaultCliError) {
+        return error.code;
+    }
+    const code = readAssistantCronErrorRecord(error)?.code;
+    const normalized = typeof code === 'string' ? code.trim() : '';
+    return normalized.length > 0 ? normalized : null;
+}
+function readAssistantCronErrorRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : null;
 }
 function finalizeCanonicalAssistantCronRuntimeAfterRun(input) {
     const runningClearedState = {
@@ -579,7 +980,34 @@ function finalizeCanonicalAssistantCronRuntimeAfterRun(input) {
         runningPid: null,
         lastRunAt: input.finishedAt,
     };
-    if (assistantCronRunConsumedOccurrence(input.run, input.pendingDeliveryIntentId)) {
+    if (input.foregroundYielded) {
+        return {
+            ...input.runtimeState,
+            updatedAt: input.finishedAt,
+            state: {
+                ...runningClearedState,
+                pendingOccurrenceAt: input.runtimeState.state.pendingOccurrenceAt ??
+                    resolveCanonicalAssistantCronOccurrenceAt(input.source, input.runtimeState),
+                retryAfterAt: computeAssistantCronForegroundYieldRetryAt(input.finishedAt),
+            },
+        };
+    }
+    if (assistantCronRunConsumedOccurrence(input.run, input.pendingDeliveryIntentId, input.failureConsumesOccurrence)) {
+        if (input.run.outcome === 'failed') {
+            return {
+                ...input.runtimeState,
+                sessionId: input.responseSessionId ?? input.runtimeState.sessionId,
+                updatedAt: input.finishedAt,
+                state: {
+                    ...runningClearedState,
+                    pendingOccurrenceAt: null,
+                    retryAfterAt: null,
+                    lastFailedAt: input.finishedAt,
+                    lastError: input.run.error,
+                    consecutiveFailures: 0,
+                },
+            };
+        }
         return {
             ...input.runtimeState,
             sessionId: input.responseSessionId ?? input.runtimeState.sessionId,
@@ -594,7 +1022,7 @@ function finalizeCanonicalAssistantCronRuntimeAfterRun(input) {
             },
         };
     }
-    if (input.run.status === 'skipped' && input.pendingDeliveryIntentId !== null) {
+    if (input.run.outcome === 'delivery_pending' && input.pendingDeliveryIntentId !== null) {
         return {
             ...input.runtimeState,
             sessionId: input.responseSessionId ?? input.runtimeState.sessionId,
@@ -632,36 +1060,63 @@ function assistantCronJobHasStableSessionLocator(job) {
         (job.target.channel &&
             (job.target.participantId || job.target.threadId)));
 }
-async function resolveDeviceActivityParentAuthorityError(input) {
+async function resolveDeviceActivityParentAuthority(input) {
     if (input.job.kind !== 'local') {
-        return null;
+        return {
+            assistantTargetOverride: null,
+            error: null,
+            route: null,
+        };
     }
     const metadata = readAssistantDeviceActivityCronJobMetadata(input.job.job.name);
     if (!metadata) {
-        return null;
+        return {
+            assistantTargetOverride: null,
+            error: null,
+            route: null,
+        };
     }
     const parentAutomation = await readAssistantDeviceActivityParentAutomation({
         metadata,
         vault: input.vault,
     });
     if (!parentAutomation || parentAutomation.status !== 'active') {
-        return ASSISTANT_DEVICE_ACTIVITY_AUTHORITY_STALE_ERROR;
+        return {
+            assistantTargetOverride: null,
+            error: ASSISTANT_DEVICE_ACTIVITY_AUTHORITY_STALE_ERROR,
+            route: null,
+        };
     }
     if (parentAutomation.schedule.kind !== 'deviceActivity') {
-        return ASSISTANT_DEVICE_ACTIVITY_AUTHORITY_STALE_ERROR;
-    }
-    if (!assistantCronTargetMatchesAutomationRoute(input.job.job.target, parentAutomation.route)) {
-        return ASSISTANT_DEVICE_ACTIVITY_AUTHORITY_STALE_ERROR;
+        return {
+            assistantTargetOverride: null,
+            error: ASSISTANT_DEVICE_ACTIVITY_AUTHORITY_STALE_ERROR,
+            route: null,
+        };
     }
-    return buildAssistantDeviceActivityAuthorityKey({
-        ...parentAutomation,
-        schedule: {
-            activityKind: parentAutomation.schedule.activityKind,
-            source: parentAutomation.schedule.source,
+    const authorityMatches = assistantDeviceActivityAuthorityKeyMatches({
+        authorityKey: metadata.authorityKey,
+        automation: {
+            ...parentAutomation,
+            schedule: {
+                activityKind: parentAutomation.schedule.activityKind,
+                source: parentAutomation.schedule.source,
+            },
         },
-    }) === metadata.authorityKey
-        ? null
-        : ASSISTANT_DEVICE_ACTIVITY_AUTHORITY_STALE_ERROR;
+    });
+    if (!authorityMatches ||
+        !assistantCronTargetMatchesAutomationRoute(input.job.job.target, parentAutomation.route)) {
+        return {
+            assistantTargetOverride: null,
+            error: ASSISTANT_DEVICE_ACTIVITY_AUTHORITY_STALE_ERROR,
+            route: null,
+        };
+    }
+    return {
+        assistantTargetOverride: parentAutomation.assistantTargetOverride,
+        error: null,
+        route: parentAutomation.route,
+    };
 }
 function assistantCronTargetMatchesAutomationRoute(target, route) {
     return target.channel === route.channel &&
@@ -669,7 +1124,10 @@ function assistantCronTargetMatchesAutomationRoute(target, route) {
         target.deliveryTarget === route.deliveryTarget &&
         target.identityId === route.identityId &&
         target.participantId === route.participantId &&
-        target.threadId === route.threadId;
+        target.threadId === route.threadId &&
+        ((target.threadIsDirect ?? null) === (route.threadIsDirect ?? null) ||
+            (!Object.hasOwn(target, 'threadIsDirect') &&
+                typeof route.threadIsDirect === 'boolean'));
 }
 function truncateAssistantCronResponse(response) {
     if (response === null) {
@@ -677,6 +1135,26 @@ function truncateAssistantCronResponse(response) {
     }
     return response.slice(0, ASSISTANT_CRON_MAX_RESPONSE_LENGTH);
 }
+function legacyAssistantCronRunStatusForOutcome(input) {
+    switch (input.outcome) {
+        case 'delivered':
+            return 'succeeded';
+        case 'no_op':
+            return input.reason === 'background_maintenance_non_replayable_work'
+                ? 'skipped'
+                : 'succeeded';
+        case 'delivery_pending':
+        case 'expired':
+        case 'skipped_gate':
+            return 'skipped';
+        case 'failed':
+            return 'failed';
+    }
+}
+function normalizeAssistantCronRunReason(reason) {
+    const normalized = reason.trim().replace(/\s+/gu, '_').slice(0, 120);
+    return normalized.length > 0 ? normalized : 'unknown';
+}
 function resolveStaleAssistantCronNotificationError(input) {
     if (input.job.scheduledLog) {
         return null;
@@ -691,32 +1169,195 @@ function resolveStaleAssistantCronNotificationError(input) {
         return null;
     }
     const lateMinutes = Math.floor(ageMs / 60_000);
-    return `${ASSISTANT_CRON_NOTIFICATION_EXPIRED_ERROR} Scheduled occurrence was ${lateMinutes} minute(s) late.`;
+    return {
+        latenessMinutes: lateMinutes,
+        message: `${ASSISTANT_CRON_NOTIFICATION_EXPIRED_ERROR} Scheduled occurrence was ${lateMinutes} minute(s) late.`,
+    };
+}
+function emitAssistantCronOccurrenceExpiredEvent(input) {
+    const automationSlug = resolveAssistantCronAutomationSlug(input.job);
+    if (!automationSlug) {
+        return;
+    }
+    input.onEvent?.({
+        type: 'cron.occurrence.expired',
+        details: 'scheduled occurrence expired before delivery',
+        safeDetails: 'cron_occurrence_expired',
+        failureContext: {
+            automationSlug,
+            latenessMinutes: input.latenessMinutes,
+        },
+        providerKind: 'status',
+        providerState: 'completed',
+    });
+}
+function resolveAssistantCronAutomationSlug(job) {
+    if (job.kind !== 'canonical' || job.source.kind !== 'automation') {
+        return null;
+    }
+    return normalizeAssistantCronAutomationSlug(job.source.slug) ??
+        normalizeAssistantCronAutomationSlug(job.job.name);
+}
+function normalizeAssistantCronAutomationSlug(value) {
+    const normalized = value
+        ?.trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/gu, '-')
+        .replace(/^-+|-+$/gu, '');
+    return normalized && normalized.length > 0 ? normalized : null;
 }
 function assistantCronExecutionDeliveryTargetProfile(input) {
     const isHostedExecution = normalizeNullableString(input.executionContext?.hosted?.memberId) !== null;
     return isHostedExecution ? 'hosted' : 'local';
 }
+async function resolveAssistantCronAuthorizedNotificationDeliveryRoute(input) {
+    const route = resolveAssistantCronNotificationDeliveryRoute(input.target);
+    if (assistantCronExecutionDeliveryTargetProfile(input) !== 'hosted' ||
+        input.target.channel !== 'linq') {
+        return route;
+    }
+    const target = normalizeNullableString(route.deliveryTarget ?? route.bindingDelivery?.target);
+    const targetKind = route.deliveryTarget || route.bindingDelivery?.kind === 'participant'
+        ? 'explicit'
+        : route.bindingDelivery?.kind === 'thread'
+            ? 'thread'
+            : null;
+    if (!target || !targetKind) {
+        throw new VaultCliError('ASSISTANT_CRON_DELIVERY_REQUIRED', 'Assistant cron jobs must bind one concrete Linq destination.');
+    }
+    const resolveScheduledLinqRoute = input.executionContext?.hosted?.resolveScheduledLinqRoute;
+    if (!resolveScheduledLinqRoute) {
+        throw new VaultCliError('ASSISTANT_LINQ_AUDIENCE_AUTHORITY_UNAVAILABLE', 'Hosted Linq delivery requires direct or group authority before provider work.', { retryable: true });
+    }
+    const authority = await resolveScheduledLinqRoute({
+        homeRouteFallbackAllowed: route.threadIsDirect !== false,
+        signal: input.signal,
+        target,
+        targetKind,
+    });
+    const authorizedTarget = normalizeNullableString(authority.target);
+    if (!authorizedTarget || typeof authority.threadIsDirect !== 'boolean') {
+        throw new VaultCliError('ASSISTANT_LINQ_AUDIENCE_AUTHORITY_UNAVAILABLE', 'Hosted Linq delivery requires direct or group authority before provider work.', { retryable: true });
+    }
+    const bindingDelivery = route.bindingDelivery
+        ? {
+            kind: route.bindingDelivery.kind === 'participant'
+                ? 'thread'
+                : route.bindingDelivery.kind,
+            target: authorizedTarget,
+        }
+        : null;
+    return {
+        bindingDelivery,
+        deliveryTarget: route.deliveryTarget === null ? null : authorizedTarget,
+        threadIsDirect: authority.threadIsDirect,
+    };
+}
+class AssistantCronForegroundYieldedError extends VaultCliError {
+    constructor(jobName) {
+        super('ASSISTANT_CRON_FOREGROUND_YIELDED', `Assistant cron job "${jobName}" yielded to fresh foreground input.`);
+    }
+}
+function buildAssistantCronForegroundYieldedError(jobName) {
+    return new AssistantCronForegroundYieldedError(jobName);
+}
+function assertAssistantCronForegroundNotYielded(input) {
+    if (input.shouldYield?.() === true) {
+        throw buildAssistantCronForegroundYieldedError(input.jobName);
+    }
+}
+async function preemptAssistantCronNotificationCommitForForeground(input) {
+    const foregroundYielded = input.foregroundPreemption.wasForegroundYielded()
+        || input.shouldYield?.() === true;
+    if (!foregroundYielded) {
+        return;
+    }
+    if (input.allowTerminalNoDelivery) {
+        return;
+    }
+    const deliveryOutcome = input.deliveryOutcome;
+    if (deliveryOutcome?.kind === 'sent') {
+        return;
+    }
+    if (deliveryOutcome?.kind === 'queued') {
+        const abandonedIntent = await markAssistantOutboxIntentMirrorTerminalById({
+            error: buildAssistantCronForegroundYieldedError(input.jobName),
+            intentId: deliveryOutcome.intentId,
+            onlyCurrentStatuses: ['pending', 'retryable', 'awaiting_approval'],
+            status: 'abandoned',
+            vault: input.vault,
+        });
+        if (abandonedIntent !== null && abandonedIntent.status !== 'abandoned') {
+            return;
+        }
+    }
+    throw buildAssistantCronForegroundYieldedError(input.jobName);
+}
+function createAssistantCronForegroundPreemption(input) {
+    if (!input.shouldYield) {
+        return {
+            dispose: () => { },
+            signal: input.parentSignal,
+            wasForegroundYielded: () => false,
+        };
+    }
+    const controller = new AbortController();
+    let foregroundYielded = false;
+    let disposed = false;
+    let interval = null;
+    const abortForForeground = () => {
+        if (disposed || controller.signal.aborted) {
+            return;
+        }
+        foregroundYielded = true;
+        controller.abort(buildAssistantCronForegroundYieldedError(input.jobName));
+    };
+    const checkForeground = () => {
+        if (input.shouldYield?.() === true) {
+            abortForForeground();
+        }
+    };
+    const abortFromParent = () => {
+        if (disposed || controller.signal.aborted) {
+            return;
+        }
+        controller.abort(input.parentSignal?.reason);
+    };
+    if (input.parentSignal?.aborted) {
+        abortFromParent();
+    }
+    else {
+        input.parentSignal?.addEventListener('abort', abortFromParent, { once: true });
+    }
+    checkForeground();
+    interval = setInterval(checkForeground, 50);
+    interval.unref?.();
+    return {
+        dispose: () => {
+            disposed = true;
+            if (interval) {
+                clearInterval(interval);
+            }
+            input.parentSignal?.removeEventListener('abort', abortFromParent);
+        },
+        signal: controller.signal,
+        wasForegroundYielded: () => foregroundYielded,
+    };
+}
+function computeAssistantCronForegroundYieldRetryAt(finishedAt) {
+    return new Date(Date.parse(finishedAt) + 10_000).toISOString();
+}
 function cryptoRandomRunId() {
     return `cronrun_${randomUUID().replace(/-/gu, '')}`;
 }
 function resolveNextDueAssistantCronCandidate(input) {
-    const visibleLocalStore = buildVisibleLocalAssistantCronStore(input.localStore);
-    const canonicalEntries = input.canonicalRecords.map((source) => {
-        const runtimeState = resolveCanonicalRuntimeState(source, input.runtimeStore);
-        return {
-            source,
-            runtimeState,
-            job: projectCanonicalAssistantCronJob({
-                source,
-                runtimeState,
-            }),
-        };
+    const projection = buildRunnableAssistantCronJobProjection({
+        canonicalRecords: input.canonicalRecords,
+        localStore: input.localStore,
+        runtimeScopeInput: input.runtimeScopeInput,
+        runtimeStore: input.runtimeStore,
     });
-    const candidate = sortAssistantCronJobs([
-        ...visibleLocalStore.jobs,
-        ...canonicalEntries.map((entry) => entry.job),
-    ]).find((job) => isAssistantCronJobDue(job, input.nowIso));
+    const candidate = projection.jobs.find((job) => isAssistantCronJobDue(job, input.nowIso));
     if (!candidate) {
         return null;
     }
@@ -727,12 +1368,26 @@ function resolveNextDueAssistantCronCandidate(input) {
             localJob,
         };
     }
-    const canonicalEntry = canonicalEntries.find((entry) => resolveCanonicalAssistantCronJobId(entry.source) === candidate.jobId);
+    const canonicalEntry = projection.canonicalEntries.find((entry) => resolveCanonicalAssistantCronJobId(entry.source) === candidate.jobId);
     return {
         job: candidate,
         ...(canonicalEntry ? { canonicalEntry } : {}),
     };
 }
+// Background maintenance is hosted-only; everything else runs anywhere.
+function canonicalAssistantCronSourceCanRunInRuntime(input) {
+    return !canonicalAssistantCronSourceIsBackgroundMaintenance(input.source) ||
+        input.hostedRuntimeProcess;
+}
+export function canonicalAssistantCronSourceIsBackgroundMaintenance(source) {
+    return source.kind === 'automation' &&
+        source.automationId === MURPH_OVERNIGHT_MEMORY_CONSOLIDATION_AUTOMATION_ID;
+}
+function resolveAssistantCronRuntimeScope(input) {
+    return input.executionContext?.hosted != null ||
+        isHostedRuntimeProcessEnv(input.turnEnvironment?.env ?? {}) ||
+        isHostedRuntimeProcessEnv(process.env);
+}
 function cryptoRandomCronClaimId() {
     return `cronclaim_${randomUUID().replace(/-/gu, '')}`;
 }
@@ -747,4 +1402,113 @@ async function assertCanonicalRuntimeClaimCurrent(input) {
         throw new VaultCliError('ASSISTANT_CRON_CLAIM_LOST', `Assistant cron job "${input.job.job.name}" was reclaimed before it started.`);
     }
 }
+function createAssistantCronBackgroundMaintenanceCancellation(input) {
+    if (!assistantCronJobIsPreemptibleBackgroundMaintenance(input.job)) {
+        return {
+            dispose() { },
+            shouldYield: () => false,
+            yieldRequested: () => false,
+            signal: input.signal ?? new AbortController().signal,
+        };
+    }
+    const controller = new AbortController();
+    let yielded = false;
+    const abortForYield = () => {
+        yielded = true;
+        if (!controller.signal.aborted) {
+            controller.abort(createAssistantCronBackgroundMaintenanceYieldError());
+        }
+    };
+    const abortForParent = () => {
+        if (!controller.signal.aborted) {
+            controller.abort(input.signal?.reason);
+        }
+    };
+    const checkYield = () => {
+        if (input.shouldYieldBackgroundMaintenance?.() === true) {
+            abortForYield();
+        }
+    };
+    if (input.signal?.aborted) {
+        abortForParent();
+    }
+    else {
+        input.signal?.addEventListener('abort', abortForParent, { once: true });
+    }
+    checkYield();
+    const timer = input.shouldYieldBackgroundMaintenance &&
+        !controller.signal.aborted
+        ? setInterval(checkYield, ASSISTANT_CRON_BACKGROUND_MAINTENANCE_YIELD_POLL_MS)
+        : null;
+    if (timer && typeof timer.unref === 'function') {
+        timer.unref();
+    }
+    return {
+        dispose() {
+            if (timer) {
+                clearInterval(timer);
+            }
+            input.signal?.removeEventListener('abort', abortForParent);
+        },
+        shouldYield() {
+            if (yielded) {
+                return true;
+            }
+            if (input.shouldYieldBackgroundMaintenance?.() === true) {
+                abortForYield();
+                return true;
+            }
+            return false;
+        },
+        yieldRequested() {
+            return yielded;
+        },
+        signal: controller.signal,
+    };
+}
+function assistantNotificationErrorHasNonReplayableProviderWork(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const details = Reflect.get(error, 'details');
+    if (typeof details !== 'object' || details === null || Array.isArray(details)) {
+        return false;
+    }
+    return Reflect.get(details, 'assistantNotificationProviderNonReplayableWork') === true;
+}
+function assistantCronJobIsPreemptibleBackgroundMaintenance(job) {
+    return job.kind === 'canonical' &&
+        canonicalAssistantCronSourceIsBackgroundMaintenance(job.source);
+}
+function createAssistantCronBackgroundMaintenanceYieldError() {
+    return new VaultCliError(ASSISTANT_CRON_BACKGROUND_MAINTENANCE_YIELDED_CODE, 'Assistant cron background maintenance yielded to foreground input.');
+}
+async function releaseClaimedAssistantCronJobAfterBackgroundMaintenanceYield(input) {
+    if (input.job.kind !== 'canonical') {
+        return;
+    }
+    const job = input.job;
+    await withAssistantCronWriteLock(input.paths, async () => {
+        const runtimeStore = await readAssistantCronCanonicalRuntimeStore(input.paths, {
+            reclaimStaleRunningClaims: false,
+        });
+        const currentRuntimeState = findAssistantCronCanonicalRuntimeRecord(runtimeStore, resolveCanonicalAssistantCronJobId(job.source)) ?? job.runtimeState;
+        if (!canonicalRuntimeClaimMatches(job.runtimeState, currentRuntimeState)) {
+            return;
+        }
+        const now = new Date().toISOString();
+        upsertAssistantCronCanonicalRuntimeRecord(runtimeStore, {
+            ...currentRuntimeState,
+            updatedAt: now,
+            state: {
+                ...currentRuntimeState.state,
+                runningAt: null,
+                runningClaimId: null,
+                runningPid: null,
+                retryAfterAt: computeAssistantCronBackgroundMaintenanceYieldRetryAt(now),
+            },
+        });
+        await writeAssistantCronCanonicalRuntimeStore(input.paths, runtimeStore);
+    });
+}
 //# sourceMappingURL=execution.js.map