@murphai/murph 1.3.0 → 1.3.2

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

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto';
-import { archiveAutomationIfActiveUntilElapsed, isVaultError, setScheduledLogStatus, upsertAutomation, } from '@murphai/core';
+import { parseAutomationSupportSeriesTag, } from '@murphai/contracts';
+import { archiveAutomationIfActiveUntilElapsed, isVaultError, setScheduledLogStatus, splitAutomationAvailabilityConflictBlock, stripAutomationAvailabilityConflictEvidenceForProvider, upsertAutomation, } from '@murphai/core';
 import { isHostedRuntimeProcessEnv, } from '@murphai/hosted-execution/env';
 import {} from '@murphai/query';
 import { assistantCronJobSchema, assistantCronRunRecordSchema, } from '@murphai/operator-config/assistant-cli-contracts';
@@ -8,28 +9,30 @@ 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 { isRetiredMurphManagedAutomationId, resolveMurphManagedAutomationOwnerScope, resolveMurphManagedMaintenancePolicy, } from '../managed-automations.js';
-import { readAssistantOnboardingState } from '../onboarding-state.js';
+import { appendAssistantHostedDynamicContextPrompt, } from '../execution-context.js';
+import { isRetiredMurphManagedAutomationId, isRecognizedMurphOnboardingFollowupAutomation, MURPH_MONTHLY_IMPROVEMENT_COACH_AUTOMATION_ID, MURPH_WEEKLY_HEALTH_INSIGHT_AUTOMATION_ID, MURPH_WEEKLY_HEALTH_RESEARCH_SCOUT_AUTOMATION_ID, resolveMurphManagedAutomationOwnerScope, resolveMurphManagedMaintenancePolicy, } from '../managed-automations.js';
+import { isAssistantOnboardingStateReadError, readAssistantOnboardingState, } from '../onboarding-state.js';
+import { isCurrentMurphOnboardingFollowupAutomation, } from '../onboarding-followup-automation.js';
 import { runOnboardingGoalCheckinAuthorityPrecondition, } from '../onboarding-goal-checkin-automation.js';
-import { resolveGroupNewsletterAutomationDelivery, } from '../group-newsletter-automation.js';
-import { findAssistantNewsletterParentIntent, } from '../newsletter-outbox.js';
+import { buildAssistantLinqDeliveryPosturePrompt, } from '../linq-delivery-posture.js';
+import { findAssistantGroupEmailParentIntent, } from '../group-email-outbox.js';
 import { runExperimentLifecycleDeliveryAuthorityPrecondition, runExperimentLifecycleOutcomePrecondition, } from '../experiment-support-automations.js';
 import { assistantDeliveryErrorPreventsFreshIntentRetry, isAssistantOutboxRetryableError, markAssistantOutboxIntentMirrorTerminalById, } from '../outbox.js';
-import { errorMessage, normalizeNullableString } from '../shared.js';
+import { ASSISTANT_BOUNDED_CONVERSATION_HISTORY_INCOMPLETE_TEXT, errorMessage, normalizeNullableString, } from '../shared.js';
 import { resolveAssistantStatePaths, } from '../store/paths.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 { assistantCronScheduleHasSingleDailyTime } from './schedule.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 { buildCanonicalAutomationUpsertInput, buildVisibleLocalAssistantCronStore, isAssistantCronNotificationOccurrenceFresh, isCanonicalAssistantCronNotificationOccurrenceDeliverable, isCanonicalAssistantCronSourceEnabled, automationContinuityUsesSessionPin, listCanonicalAssistantCronRecords, projectCanonicalAssistantCronJob, resolveCanonicalAssistantCronJobId, resolveCanonicalAssistantCronOccurrenceAt, resolveCanonicalRuntimeState, } from './canonical-jobs.js';
 import { appendAssistantCronRun, buildAssistantCronTarget, isAssistantCronJobDue, readAssistantCronStore, resolveAssistantCronJobIndex, sortAssistantCronJobs, writeAssistantCronStore, } from './store.js';
 import { resolveAssistantCronFailureBackoffMs, resolveAssistantCronNextRunAfterSuccess, } from './finalization.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.';
@@ -37,18 +40,23 @@ const ASSISTANT_CRON_MANAGED_OWNER_SCOPE_MISMATCH_ERROR = 'Managed automation ow
 const HOSTED_LINQ_EGRESS_ROUTE_AUTHORITY_MISMATCH = 'HOSTED_LINQ_EGRESS_ROUTE_AUTHORITY_MISMATCH';
 const ASSISTANT_CRON_MANAGED_AUTOMATION_RETIRED_ERROR = 'Managed automation has been retired.';
 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_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:monthly-improvement-coach',
-    // Legacy tag retained while existing records reconcile to the monthly seed.
-    'murph-managed:weekly-improvement-coach',
-    'murph-managed:weekly-health-research-scout',
+const ASSISTANT_CRON_ONBOARDING_FOLLOWUP_COMPLETED_ERROR = 'Assistant onboarding follow-up skipped because onboarding is completed.';
+const ASSISTANT_CRON_ONBOARDING_FOLLOWUP_RECONCILIATION_REQUIRED_ERROR = 'Assistant onboarding follow-up predecessor is waiting for managed reconciliation.';
+const MURPH_RESEARCH_ORIENTED_MANAGED_AUTOMATION_IDS = new Set([
+    MURPH_WEEKLY_HEALTH_INSIGHT_AUTOMATION_ID,
+    MURPH_MONTHLY_IMPROVEMENT_COACH_AUTOMATION_ID,
+    MURPH_WEEKLY_HEALTH_RESEARCH_SCOUT_AUTOMATION_ID,
 ]);
+export const ASSISTANT_CRON_INDEPENDENT_AUTOMATION_AUTHORITY_INSTRUCTIONS = [
+    'Independent automation authority (engine-supplied):',
+    '- This active saved automation is a current user request. Related plans and experiments are context, not cancellation authority.',
+    "- Do not treat a related plan or experiment's completion as cancellation unless the saved instructions explicitly make that state a skip condition.",
+    '- Completion of a broader plan is not proof that this occurrence\'s requested action already happened.',
+    '- You may still skip when the saved instructions authorize that outcome or current evidence proves the requested action already happened.',
+].join('\n');
 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) {
@@ -264,13 +272,17 @@ export async function executeClaimedAssistantCronJob(rawInput) {
     let outcome = 'failed';
     let reason = 'unhandled';
     let pendingDeliveryIntentId = null;
-    let newsletterRecoveryAuthorized = false;
+    let notificationDecision = null;
+    let groupEmailRecoveryAuthorized = false;
     let canonicalSourceDisposition = 'current';
     let canonicalSourceSkipReason = null;
     let managedOwnerAuthorization = {
         kind: 'unmanaged',
     };
     let managedOwnerSkipReason = null;
+    let notificationDecisionKind = null;
+    let notificationDeliveryOutcomeKind = null;
+    let onboardingFollowupDiagnostic = 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
@@ -278,6 +290,7 @@ export async function executeClaimedAssistantCronJob(rawInput) {
     // release and a spurious failed foreground-yield run.
     const maintenanceJob = assistantCronJobIsPreemptibleBackgroundMaintenance(input.job);
     let maintenanceProviderStarted = false;
+    let notificationProviderStarted = false;
     const foregroundPreemption = createAssistantCronForegroundPreemption({
         jobName: claimedJob.name,
         parentSignal: input.signal,
@@ -288,7 +301,7 @@ export async function executeClaimedAssistantCronJob(rawInput) {
             resolveCanonicalAssistantCronOccurrenceAt(input.job.source, input.job.runtimeState) ??
             startedAt
         : claimedJob.state.nextRunAt ?? startedAt;
-    const scheduledNewsletterAuthority = resolveAssistantCronScheduledNewsletterAuthority({
+    const scheduledGroupEmailAuthority = resolveAssistantCronScheduledGroupEmailAuthority({
         job: input.job,
         occurrenceAt,
         trigger: input.trigger,
@@ -327,10 +340,10 @@ export async function executeClaimedAssistantCronJob(rawInput) {
                 canonicalSourceSkipReason = authority.reason;
             }
             if (canonicalSourceSkipReason === null
-                && scheduledNewsletterAuthority) {
-                newsletterRecoveryAuthorized = true;
-                pendingDeliveryIntentId = (await findAssistantNewsletterParentIntent({
-                    authority: scheduledNewsletterAuthority,
+                && scheduledGroupEmailAuthority) {
+                groupEmailRecoveryAuthorized = true;
+                pendingDeliveryIntentId = (await findAssistantGroupEmailParentIntent({
+                    authority: scheduledGroupEmailAuthority,
                     vault: input.vault,
                 }))?.intentId ?? null;
             }
@@ -362,6 +375,25 @@ export async function executeClaimedAssistantCronJob(rawInput) {
             pendingDeliveryIntentId === null &&
             input.job.kind === 'canonical' &&
             input.job.source.kind === 'automation') {
+            const onboardingFollowup = await readAssistantCronOnboardingFollowupDiagnostic({
+                authorityGate: 'initial',
+                job: input.job,
+                occurrenceAt,
+                vault: input.vault,
+            });
+            if (onboardingFollowup) {
+                onboardingFollowupDiagnostic = onboardingFollowup.diagnostic;
+                if (isAssistantCronOnboardingFollowupPredecessorJob(input.job)) {
+                    throw buildAssistantCronOnboardingFollowupReconciliationRequiredError();
+                }
+                else if (onboardingFollowup.error) {
+                    throw onboardingFollowup.error;
+                }
+                else if (onboardingFollowup.diagnostic.onboardingStateStatus === 'completed') {
+                    lifecycleSkipReason =
+                        ASSISTANT_CRON_ONBOARDING_FOLLOWUP_COMPLETED_ERROR;
+                }
+            }
             // Route on the immutable automationId so a user-edited slug cannot
             // silently bypass the precondition.
             const onboardingAuthority = await runOnboardingGoalCheckinAuthorityPrecondition({
@@ -479,7 +511,7 @@ export async function executeClaimedAssistantCronJob(rawInput) {
                         deviceActivityAuthority.assistantTargetOverride,
                     deliveryDispatchMode: input.deliveryDispatchMode,
                     executionContext: input.executionContext,
-                    scheduledAutomationAuthority: scheduledNewsletterAuthority,
+                    scheduledAutomationAuthority: scheduledGroupEmailAuthority,
                     scheduledInvocationAuthority,
                     scheduledOccurrenceAt: occurrenceAt,
                     serviceTier,
@@ -505,6 +537,7 @@ export async function executeClaimedAssistantCronJob(rawInput) {
                     const authorizedDelivery = maintenanceJob
                         ? {
                             conversationThreadId: null,
+                            deliveryPosture: null,
                             externalThreadRouteAuthority: null,
                             route: resolveAssistantCronNotificationDeliveryRoute(claimedJob.target),
                         }
@@ -516,14 +549,18 @@ export async function executeClaimedAssistantCronJob(rawInput) {
                                 target: claimedJob.target,
                             });
                     const deliveryRoute = authorizedDelivery.route;
+                    const postureExecutionContext = appendAssistantHostedDynamicContextPrompt({
+                        executionContext: automationTurn.executionContext ?? { hosted: null },
+                        prompt: buildAssistantLinqDeliveryPosturePrompt(authorizedDelivery.deliveryPosture),
+                    });
                     const notificationExecutionContext = scopeAssistantCronScheduledGroupTools({
                         channel: claimedJob.target.channel,
-                        executionContext: automationTurn.executionContext,
+                        executionContext: postureExecutionContext,
                         route: deliveryRoute,
                         routeAuthorityVerified: !maintenanceJob,
                         scheduledInvocationAuthority,
                     });
-                    const assertNotificationStillAuthorized = async () => {
+                    const assertNotificationStillAuthorized = async (authorityGate) => {
                         const authority = await resolveAssistantCronCanonicalSourceAuthority({
                             job: input.job,
                             now: new Date(),
@@ -535,7 +572,11 @@ export async function executeClaimedAssistantCronJob(rawInput) {
                             throw new AssistantCronCanonicalSourceInvalidatedError(authority);
                         }
                         await assertAssistantCronLifecycleNotificationStillAuthorized({
+                            authorityGate,
                             job: input.job,
+                            onOnboardingFollowupDiagnostic(diagnostic) {
+                                onboardingFollowupDiagnostic = diagnostic;
+                            },
                             occurrenceAt,
                             vault: input.vault,
                         });
@@ -564,26 +605,36 @@ export async function executeClaimedAssistantCronJob(rawInput) {
                             }
                         }
                     };
+                    const recordNotificationDecision = (decision) => {
+                        if (!decision || !notificationProviderStarted) {
+                            return;
+                        }
+                        notificationDecision = decision.kind === 'skip'
+                            ? { kind: 'skip', reasonCode: 'provider_skip' }
+                            : { kind: 'send_message', reasonCode: 'provider_send_message' };
+                    };
                     const notificationInput = {
                         vault: input.vault,
                         ...automationTurn,
                         executionContext: notificationExecutionContext,
-                        // 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;
-                                },
+                        // Provider admission distinguishes provider decisions from host
+                        // gates. For maintenance it is also the replay barrier: admitted
+                        // work may have committed writes before a terminal interruption.
+                        onProviderRequestStarted: () => {
+                            notificationProviderStarted = true;
+                            if (maintenanceJob) {
+                                maintenanceProviderStarted = true;
                             }
-                            : {}),
-                        beforeProviderAcceptedInputs: assertNotificationStillAuthorized,
-                        beforeDelivery: assertNotificationStillAuthorized,
-                        beforeToolExecution: assertNotificationStillAuthorized,
+                        },
+                        beforeProviderAcceptedInputs: () => assertNotificationStillAuthorized('pre_provider'),
+                        beforeDelivery: async (context) => {
+                            recordNotificationDecision(context?.decision);
+                            await assertNotificationStillAuthorized('pre_delivery');
+                        },
+                        beforeToolExecution: () => assertNotificationStillAuthorized('pre_tool'),
                         beforeCommit: async (context) => {
-                            await assertNotificationStillAuthorized();
+                            recordNotificationDecision(context.decision);
+                            await assertNotificationStillAuthorized('pre_commit');
                             await preemptAssistantCronNotificationCommitForForeground({
                                 allowTerminalNoDelivery: assistantCronDeviceActivitySkipConsumesOccurrence({
                                     decision: context.decision,
@@ -597,7 +648,11 @@ export async function executeClaimedAssistantCronJob(rawInput) {
                                 vault: input.vault,
                             });
                         },
-                        instructions: buildAssistantCronExecutionInstructions(input.job),
+                        instructions: buildAssistantCronExecutionInstructions(input.job, deviceActivityAuthority),
+                        scheduledAutomationScheduleKind: input.job.kind === 'canonical'
+                            && input.job.source.kind === 'automation'
+                            ? input.job.source.schedule.kind
+                            : null,
                         deliveryDedupeToken: buildAssistantCronNotificationDedupeToken({
                             job: claimedJob,
                             trigger: input.trigger,
@@ -616,10 +671,15 @@ export async function executeClaimedAssistantCronJob(rawInput) {
                         channel: claimedJob.target.channel,
                         identityId: claimedJob.target.identityId,
                         onTraceEvent: input.onTraceEvent,
-                        onNewsletterPendingDeliveryIntentId: (intentId) => {
+                        onGroupEmailPendingDeliveryIntentId: (intentId) => {
                             pendingDeliveryIntentId = intentId;
                         },
                         outboxAutomationAuthority: resolveAssistantCronOutboxAutomationAuthority(input.job),
+                        outboxAutomationContextReferences: resolveAssistantCronOutboxAutomationContextReferences(input.job, deviceActivityAuthority),
+                        outboxPlannedOccurrenceAt: resolveAssistantCronOutboxPlannedOccurrenceAt({
+                            job: input.job,
+                            occurrenceAt,
+                        }),
                         outboxExternalThreadRouteAuthority: authorizedDelivery.externalThreadRouteAuthority,
                         participantId: claimedJob.target.participantId,
                         turnPolicy: resolveAssistantCronNotificationTurnPolicy(input.job),
@@ -638,17 +698,12 @@ export async function executeClaimedAssistantCronJob(rawInput) {
                         workingDirectory: input.vault,
                     };
                     const result = await sendAssistantNotificationLocal(notificationInput);
+                    recordNotificationDecision(result.decision);
                     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);
-                    }
+                    notificationDecisionKind = result.decision?.kind ?? null;
+                    notificationDeliveryOutcomeKind =
+                        result.deliveryOutcome?.kind ?? 'none';
                     const foregroundYieldedAfterNotification = !maintenanceJob &&
                         (foregroundPreemption.wasForegroundYielded() ||
                             input.shouldYield?.() === true);
@@ -657,9 +712,12 @@ export async function executeClaimedAssistantCronJob(rawInput) {
                         deliveryOutcome: result.deliveryOutcome ?? null,
                         job: input.job,
                     });
-                    const newsletterPendingDeliveryIntentId = resolveAssistantCronNewsletterPendingDeliveryIntentId(result);
-                    if (newsletterPendingDeliveryIntentId) {
-                        pendingDeliveryIntentId = newsletterPendingDeliveryIntentId;
+                    const groupEmailPendingDeliveryIntentId = resolveAssistantCronGroupEmailPendingDeliveryIntentId(result);
+                    if (assistantCronGroupEmailAttemptFailed(result)) {
+                        throw new VaultCliError('ASSISTANT_GROUP_EMAIL_DELIVERY_FAILED', 'Group email delivery did not complete.');
+                    }
+                    if (groupEmailPendingDeliveryIntentId) {
+                        pendingDeliveryIntentId = groupEmailPendingDeliveryIntentId;
                         outcome = 'delivery_pending';
                         reason = 'delivery_pending';
                     }
@@ -692,11 +750,11 @@ export async function executeClaimedAssistantCronJob(rawInput) {
     }
     catch (error) {
         if (pendingDeliveryIntentId === null
-            && newsletterRecoveryAuthorized
-            && scheduledNewsletterAuthority) {
+            && groupEmailRecoveryAuthorized
+            && scheduledGroupEmailAuthority) {
             try {
-                pendingDeliveryIntentId = (await findAssistantNewsletterParentIntent({
-                    authority: scheduledNewsletterAuthority,
+                pendingDeliveryIntentId = (await findAssistantGroupEmailParentIntent({
+                    authority: scheduledGroupEmailAuthority,
                     vault: input.vault,
                 }))?.intentId ?? null;
             }
@@ -759,6 +817,12 @@ export async function executeClaimedAssistantCronJob(rawInput) {
             outcome = 'skipped_gate';
             reason = 'managed_owner_scope_mismatch';
         }
+        else if (error instanceof AssistantCronLinqHealthPreflightBlockedError) {
+            errorText = error.message;
+            errorCode = error.code;
+            outcome = 'skipped_gate';
+            reason = 'linq_health_preflight';
+        }
         else {
             const yieldedError = error instanceof AssistantCronForegroundYieldedError ||
                 (foregroundPreemption.wasForegroundYielded() &&
@@ -809,6 +873,8 @@ export async function executeClaimedAssistantCronJob(rawInput) {
         response: truncateAssistantCronResponse(response),
         responseLength: response?.length ?? 0,
         error: errorText,
+        notificationDecision,
+        scheduledOccurrenceAt: occurrenceAt,
     });
     const finalized = await withAssistantCronWriteLock(input.paths, async () => {
         if (input.job.kind === 'local') {
@@ -931,6 +997,13 @@ export async function executeClaimedAssistantCronJob(rawInput) {
             removedAfterRun,
         };
     });
+    emitAssistantCronOnboardingFollowupCompletedEvent({
+        diagnostic: onboardingFollowupDiagnostic,
+        notificationDecisionKind,
+        notificationDeliveryOutcomeKind,
+        onEvent: input.onEvent,
+        run,
+    });
     return {
         job: finalized.job,
         removedAfterRun: finalized.removedAfterRun,
@@ -954,10 +1027,97 @@ async function resolveResearchOrientedManagedAutomationOnboardingSkipError(input
         return ASSISTANT_CRON_ONBOARDING_UNREADABLE_RESEARCH_SKIP_ERROR;
     }
 }
+async function readAssistantCronOnboardingFollowupDiagnostic(input) {
+    if (!isAssistantCronOnboardingFollowupJob(input.job)) {
+        return null;
+    }
+    if (input.job.source.kind !== 'automation') {
+        return null;
+    }
+    const base = {
+        activeUntil: input.job.source.activeUntil,
+        authorityGate: input.authorityGate,
+        occurrenceAt: input.occurrenceAt,
+        scheduleKind: input.job.source.schedule.kind,
+    };
+    try {
+        const state = await readAssistantOnboardingState(input.vault);
+        return {
+            diagnostic: {
+                ...base,
+                onboardingStateCreatedAt: state.createdAt,
+                onboardingStateReadError: null,
+                onboardingStateSource: state.createdAt === null ? 'default_missing' : 'persisted',
+                onboardingStateStatus: state.status,
+                onboardingStateUpdatedAt: state.updatedAt,
+            },
+            error: null,
+        };
+    }
+    catch (error) {
+        const onboardingStateReadError = isAssistantOnboardingStateReadError(error);
+        const authorityError = onboardingStateReadError
+            ? new VaultCliError('ASSISTANT_ONBOARDING_AUTHORITY_UNAVAILABLE', 'Onboarding follow-up authority could not be revalidated.', {
+                reason: error.reason,
+                retryable: true,
+            })
+            : error;
+        return {
+            diagnostic: {
+                ...base,
+                onboardingStateCreatedAt: null,
+                onboardingStateReadError: onboardingStateReadError
+                    ? error.reason
+                    : 'unknown',
+                onboardingStateSource: 'read_error',
+                onboardingStateStatus: 'unreadable',
+                onboardingStateUpdatedAt: null,
+            },
+            error: authorityError,
+        };
+    }
+}
+function isAssistantCronOnboardingFollowupJob(job) {
+    if (job.kind !== 'canonical' || job.source.kind !== 'automation') {
+        return false;
+    }
+    return isRecognizedMurphOnboardingFollowupAutomation(job.source);
+}
+function isAssistantCronOnboardingFollowupPredecessorJob(job) {
+    return isAssistantCronOnboardingFollowupJob(job) &&
+        !isCurrentMurphOnboardingFollowupAutomation(job.source);
+}
+function emitAssistantCronOnboardingFollowupCompletedEvent(input) {
+    if (!input.diagnostic) {
+        return;
+    }
+    input.onEvent?.({
+        type: 'onboarding.followup.completed',
+        details: 'onboarding follow-up occurrence completed',
+        safeDetails: 'onboarding_followup_completed',
+        failureContext: {
+            activeUntil: input.diagnostic.activeUntil,
+            authorityGate: input.diagnostic.authorityGate,
+            occurrenceAt: input.diagnostic.occurrenceAt,
+            notificationDecisionKind: input.notificationDecisionKind,
+            notificationDeliveryOutcomeKind: input.notificationDeliveryOutcomeKind,
+            onboardingStateCreatedAt: input.diagnostic.onboardingStateCreatedAt,
+            onboardingStateReadError: input.diagnostic.onboardingStateReadError,
+            onboardingStateSource: input.diagnostic.onboardingStateSource,
+            onboardingStateStatus: input.diagnostic.onboardingStateStatus,
+            onboardingStateUpdatedAt: input.diagnostic.onboardingStateUpdatedAt,
+            runOutcome: input.run.outcome,
+            runReason: input.run.reason,
+            scheduleKind: input.diagnostic.scheduleKind,
+        },
+        providerKind: 'status',
+        providerState: 'completed',
+    });
+}
 function isResearchOrientedManagedAutomationCronJob(job) {
     return (job.kind === 'canonical' &&
         job.source.kind === 'automation' &&
-        job.source.tags.some((tag) => MURPH_RESEARCH_ORIENTED_MANAGED_AUTOMATION_TAGS.has(tag)));
+        MURPH_RESEARCH_ORIENTED_MANAGED_AUTOMATION_IDS.has(job.source.automationId));
 }
 async function resolveAssistantCronCanonicalSourceAuthority(input) {
     if (input.job.kind !== 'canonical' ||
@@ -1008,6 +1168,24 @@ async function assertAssistantCronLifecycleNotificationStillAuthorized(input) {
         input.job.source.kind !== 'automation') {
         return;
     }
+    if (isAssistantCronOnboardingFollowupPredecessorJob(input.job)) {
+        throw buildAssistantCronOnboardingFollowupReconciliationRequiredError();
+    }
+    const onboardingFollowup = await readAssistantCronOnboardingFollowupDiagnostic({
+        authorityGate: input.authorityGate,
+        job: input.job,
+        occurrenceAt: input.occurrenceAt,
+        vault: input.vault,
+    });
+    if (onboardingFollowup) {
+        input.onOnboardingFollowupDiagnostic?.(onboardingFollowup.diagnostic);
+    }
+    if (onboardingFollowup?.error) {
+        throw onboardingFollowup.error;
+    }
+    if (onboardingFollowup?.diagnostic.onboardingStateStatus === 'completed') {
+        throw new AssistantCronLifecycleNotificationInvalidatedError(ASSISTANT_CRON_ONBOARDING_FOLLOWUP_COMPLETED_ERROR);
+    }
     const onboardingAuthority = await runOnboardingGoalCheckinAuthorityPrecondition({
         automationId: input.job.source.automationId,
         occurrenceAt: input.occurrenceAt,
@@ -1036,12 +1214,40 @@ function resolveAssistantCronOutboxAutomationAuthority(job) {
     if (job.source.status !== 'active') {
         return null;
     }
+    const supportSeriesId = resolveAssistantCronOutboxSupportSeriesId(job.source.tags);
     return {
         automationId: job.source.automationId,
         expectedUpdatedAt: job.source.updatedAt,
+        ...(supportSeriesId === null ? {} : { supportSeriesId }),
     };
 }
-function buildAssistantCronExecutionInstructions(job) {
+function resolveAssistantCronOutboxAutomationContextReferences(job, deviceActivityAuthority) {
+    if (job.kind === 'canonical' && job.source.kind === 'automation') {
+        return [...job.source.contextReferences];
+    }
+    return deviceActivityAuthority.automationId === null
+        ? undefined
+        : [...deviceActivityAuthority.contextReferences];
+}
+function resolveAssistantCronOutboxPlannedOccurrenceAt(input) {
+    if (input.job.kind !== 'canonical'
+        || input.job.source.kind !== 'automation'
+        || input.job.source.plannedOccurrenceOffsetMs === null) {
+        return null;
+    }
+    const plannedOccurrenceAt = new Date(Date.parse(input.occurrenceAt) + input.job.source.plannedOccurrenceOffsetMs);
+    if (Number.isNaN(plannedOccurrenceAt.getTime())) {
+        throw new TypeError('Automation planned occurrence is outside the supported date range.');
+    }
+    return plannedOccurrenceAt.toISOString();
+}
+function resolveAssistantCronOutboxSupportSeriesId(tags) {
+    const supportSeriesIds = [...new Set(tags
+            .map((tag) => parseAutomationSupportSeriesTag(tag)?.seriesId ?? null)
+            .filter((seriesId) => seriesId !== null))];
+    return supportSeriesIds.length === 1 ? supportSeriesIds[0] : null;
+}
+export function buildAssistantCronExecutionInstructions(job, deviceActivityAuthority) {
     const lastFailedAt = job.job.state.lastFailedAt;
     const retryEvidence = !lastFailedAt ||
         !assistantCronTimestampIsLater(lastFailedAt, job.job.state.lastSucceededAt)
@@ -1052,30 +1258,126 @@ function buildAssistantCronExecutionInstructions(job) {
             '- Do not interpret the absence of a user reply to that attempt as silence, disengagement, or non-adherence.',
             '- Treat this run as the next valid delivery attempt or check-in; do not claim the prior message reached the user.',
         ].join('\n');
+    const automationContext = buildAssistantCronAutomationContextInstructions(job, deviceActivityAuthority);
     const supportScope = buildAssistantCronSupportScopeInstructions(job);
-    return [job.job.prompt, retryEvidence, supportScope]
+    const independentAuthority = buildAssistantCronIndependentAutomationAuthorityInstructions(job);
+    const recurringReminderConversation = buildAssistantCronRecurringReminderConversationInstructions(job);
+    const overlays = [
+        retryEvidence,
+        automationContext,
+        independentAuthority,
+        recurringReminderConversation,
+        supportScope,
+    ]
+        .filter((section) => section !== null);
+    const providerSafeBase = stripAutomationAvailabilityConflictEvidenceForProvider(job.job.prompt);
+    let availabilityBlock = null;
+    try {
+        availabilityBlock = splitAutomationAvailabilityConflictBlock(job.job.prompt).block;
+    }
+    catch {
+        // Malformed evidence remains fail-open for delivery and provider-private.
+        // Only a structurally valid block retains host skip authority below.
+    }
+    return [providerSafeBase, ...overlays, availabilityBlock]
         .filter((section) => section !== null)
         .join('\n\n');
 }
+function buildAssistantCronAutomationContextInstructions(job, deviceActivityAuthority) {
+    const context = job.kind === 'canonical'
+        && job.source.kind === 'automation'
+        && !assistantCronJobIsPreemptibleBackgroundMaintenance(job)
+        ? {
+            automationId: job.source.automationId,
+            contextReferences: job.source.contextReferences,
+        }
+        : deviceActivityAuthority.automationId === null
+            ? null
+            : {
+                automationId: deviceActivityAuthority.automationId,
+                contextReferences: deviceActivityAuthority.contextReferences,
+            };
+    if (context === null) {
+        return null;
+    }
+    return [
+        'Scheduled automation context (engine-supplied routing and interpretation context; not mutation authority):',
+        `- automationId: ${context.automationId}`,
+        context.contextReferences.length === 0
+            ? '- contextReferences: none supplied; do not guess a canonical record'
+            : `- contextReferences: ${JSON.stringify(context.contextReferences)}`,
+        '- Inspect each exact reference through the ordinary canonical read surface before relying on it, and use only the ordinary domain mutation tools for any write.',
+    ].join('\n');
+}
+function buildAssistantCronIndependentAutomationAuthorityInstructions(job) {
+    if (job.kind !== 'canonical' ||
+        job.source.kind !== 'automation' ||
+        job.source.status !== 'active' ||
+        job.source.supportKind !== null ||
+        resolveMurphManagedAutomationOwnerScope(job.source.automationId) !== null ||
+        job.source.tags.some((tag) => parseAutomationSupportSeriesTag(tag) !== null)) {
+        return null;
+    }
+    return ASSISTANT_CRON_INDEPENDENT_AUTOMATION_AUTHORITY_INSTRUCTIONS;
+}
 function buildAssistantCronSupportScopeInstructions(job) {
+    // Weekly-digest metadata still participates in plan consent checks, but the
+    // saved automation instructions own the provider-visible task.
     if (job.kind !== 'canonical' ||
         job.source.kind !== 'automation' ||
-        job.source.supportKind === null) {
+        job.source.supportKind === null ||
+        job.source.supportKind === 'weekly_digest') {
         return null;
     }
     const exactScope = job.source.supportKind === 'reminder'
-        ? 'Deliver only the agreed reminder purpose, including a consented first-session walkthrough when the automation says so, plus any necessary skip or invalid-state note. Do not ask a proactive repair, accountability, reflection, or follow-up question.'
+        ? 'Deliver only the agreed reminder purpose, including a consented first-session walkthrough when the automation says so, plus any necessary skip or invalid-state note. For a recurring reminder, the engine-supplied cadence-administration question is the sole allowed exception to cue-only delivery. Do not ask whether the action was completed or add a proactive repair, accountability, or reflection question.'
         : job.source.supportKind === 'check_in'
             ? 'Ask at most one narrow check-in or repair question about the current plan. Do not expand into a review, digest, or new coaching agenda.'
-            : job.source.supportKind === 'review'
-                ? "Conduct only the bounded review and ask at most one question requesting the user's continue, modify, pause, stop, or escalate decision. Do not record or apply that decision until the user replies in a later turn. Do not add a recurring accountability loop."
-                : 'Provide only the agreed weekly summary shape from current evidence. Do not append a surprise accountability, repair, or coaching question.';
+            : "Conduct only the bounded review and ask at most one question requesting the user's continue, modify, pause, stop, or escalate decision. Do not record or apply that decision until the user replies in a later turn. Do not add a recurring accountability loop.";
     return [
         'Accepted support scope (engine-supplied; this overrides any broader repair or follow-up option above):',
         `- Persisted support kind: ${job.source.supportKind}.`,
         `- ${exactScope}`,
     ].join('\n');
 }
+const ASSISTANT_CRON_RECURRING_REMINDER_CONVERSATION_HEADING = 'Recurring reminder conversation (engine-supplied; apply only when the saved request is an ordinary reminder):';
+const ASSISTANT_CRON_RECURRING_REMINDER_CONVERSATION_POLICY_LINES = [
+    '- Direct-message completion takes precedence: return `skip` for only this occurrence when a timestamp or trusted adjacent date context places a user report or assistant acknowledgment that explicitly confirms this exact action was completed in its window. Missing, stale, ambiguous, other-action, or other-occurrence evidence does not qualify; future recurrences remain active.',
+    '- The silence policy below does not apply to medication, prescribed treatment, clinician-directed care, clinical monitoring, or safety-critical reminders. Send those cues normally unless the direct-conversation completion rule above applies, the member explicitly changes or pauses them, or another authoritative skip condition applies.',
+    '- Apply a silence-based cadence question or skip only when the immediately prior confirmed output appears in this request\'s engine-supplied automation-output history. If that output is unavailable under the existing evidence-retention horizon, send the current cue normally. Do not use an assistant transcript entry alone as proof of dispatch because transcript persistence precedes delivery.',
+    '- Use recent conversation plus engine delivery evidence. A failed or unconfirmed immediately prior attempt does not count: send the current reminder normally instead of treating that attempt as unanswered.',
+    '- Otherwise find the most recent output from this automation whose dispatch was confirmed by provider acceptance or runtime `sent` state.',
+    '- If there is no such confirmed output for this revision, send the current reminder normally unless the direct-conversation completion rule above applies.',
+    '- If a relevant human reply followed that output, use it when composing the current reminder.',
+    `- When a history item with the exact text \`${ASSISTANT_BOUNDED_CONVERSATION_HISTORY_INCOMPLETE_TEXT}\` appears inside this provider request's engine-supplied recent-conversation-history section, the current cold reconstruction is incomplete because an existing retention, count, or byte bound omitted committed details. It is not a human reply and does not prove silence. For this occurrence, do not apply a silence-based cadence question or skip: continue the current cue unless retained conversation or another authoritative owner proves an explicit pause, change, or valid skip condition.`,
+    '- That marker expires after the provider request that supplied it. If it is visible only in an earlier turn of a resumed provider thread, ignore it when deciding whether a later confirmed reminder received a relevant reply.',
+    '- If no relevant human reply followed and that output already asked whether to keep, change, or pause these interruptions, return `skip`.',
+    '- Otherwise send the current concise cue and ask one natural question about whether to keep, change, or pause these interruptions.',
+    '- This question administers reminder cadence only. Do not ask whether the action was completed, infer failure or refusal from silence, increase frequency, or manufacture novelty when the same concise cue still fits.',
+    '- In a group, address the room collectively. Never assign silence, non-completion, or failure to an individual participant.',
+];
+export const ASSISTANT_CRON_RECURRING_REMINDER_CONVERSATION_INSTRUCTIONS = [
+    ASSISTANT_CRON_RECURRING_REMINDER_CONVERSATION_HEADING,
+    ...ASSISTANT_CRON_RECURRING_REMINDER_CONVERSATION_POLICY_LINES,
+].join('\n');
+function buildAssistantCronRecurringReminderConversationInstructions(job) {
+    if (job.kind !== 'canonical' ||
+        job.source.kind !== 'automation' ||
+        job.source.status !== 'active' ||
+        (job.source.supportKind !== null && job.source.supportKind !== 'reminder') ||
+        resolveMurphManagedAutomationOwnerScope(job.source.automationId) !== null ||
+        job.source.schedule.kind === 'at') {
+        return null;
+    }
+    const occurrenceEvidence = assistantCronScheduleHasSingleDailyTime(job.source.schedule)
+        ? '- Occurrence evidence (engine-supplied): this schedule has one configured local time per eligible day, so matching completion on the occurrence local date is in-window. For medication, prescribed treatment, clinical monitoring, or safety-critical reminders, also require the current time, dose, or sequence.'
+        : '- Occurrence evidence (engine-supplied): do not assume this schedule fires only once per local day. Local-date coincidence alone is insufficient; require the evidence to identify the current time, dose, or sequence.';
+    return [
+        ASSISTANT_CRON_RECURRING_REMINDER_CONVERSATION_HEADING,
+        occurrenceEvidence,
+        ...ASSISTANT_CRON_RECURRING_REMINDER_CONVERSATION_POLICY_LINES,
+    ].join('\n');
+}
 function assistantCronTimestampIsLater(candidate, reference) {
     const candidateMs = Date.parse(candidate);
     const referenceMs = reference ? Date.parse(reference) : Number.NEGATIVE_INFINITY;
@@ -1106,21 +1408,14 @@ export function resolveAssistantCronScheduledInvocationAuthority(input) {
         occurrenceAt: input.occurrenceAt,
     };
 }
-function resolveAssistantCronScheduledNewsletterAuthority(input) {
+function resolveAssistantCronScheduledGroupEmailAuthority(input) {
     if (input.trigger !== 'scheduled' ||
         input.job.kind !== 'canonical' ||
         input.job.source.kind !== 'automation' ||
         input.job.source.schedule.kind !== 'cron' ||
-        resolveGroupNewsletterAutomationDelivery(input.job.source) !== 'group_email') {
-        return null;
-    }
-    const updatedAtMs = Date.parse(input.job.source.updatedAt);
-    const occurrenceAtMs = Date.parse(input.occurrenceAt);
-    if (!Number.isFinite(updatedAtMs) || !Number.isFinite(occurrenceAtMs)) {
-        return null;
-    }
-    if (occurrenceAtMs <
-        updatedAtMs + GROUP_HEALTH_NEWSLETTER_FIRST_SEND_MINIMUM_OPT_OUT_WINDOW_MS) {
+        input.job.source.route.threadIsDirect !== false ||
+        (input.job.source.route.channel !== 'linq' &&
+            input.job.source.route.channel !== 'telegram')) {
         return null;
     }
     return {
@@ -1128,31 +1423,30 @@ function resolveAssistantCronScheduledNewsletterAuthority(input) {
         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'
-            && !resolveAssistantCronNewsletterPendingDeliveryIntentId(input.result))
-        ? ASSISTANT_CRON_NEWSLETTER_DELIVERY_FAILED_ERROR
-        : null;
-}
-function resolveAssistantCronNewsletterPendingDeliveryIntentId(result) {
+function resolveAssistantCronGroupEmailPendingDeliveryIntentId(result) {
     const expectations = result.postTurnDeliveryExpectations;
-    const intentId = expectations?.newsletterPendingDeliveryIntentId ?? null;
-    return expectations?.newsletterSendResult?.status === 'accepted'
+    const intentId = expectations?.groupEmailPendingDeliveryIntentId ?? null;
+    return expectations?.groupEmailSendResult?.status === 'accepted'
         && intentId
         && intentId.trim().length > 0
         ? intentId
         : null;
 }
+function assistantCronGroupEmailAttemptFailed(result) {
+    const sendResult = result.postTurnDeliveryExpectations?.groupEmailSendResult;
+    if (!sendResult) {
+        return false;
+    }
+    if (sendResult.status === 'unavailable') {
+        return true;
+    }
+    if (sendResult.status === 'partial_failure'
+        && sendResult.sentRecipientCount === 0) {
+        return true;
+    }
+    return sendResult.status === 'accepted'
+        && resolveAssistantCronGroupEmailPendingDeliveryIntentId(result) === null;
+}
 function resolveAssistantCronNotificationResponsePolicy(job) {
     return listAssistantCronNotificationTags(job).includes(ASSISTANT_REQUIRE_SEND_AUTOMATION_TAG)
         ? { kind: 'require_send' }
@@ -1160,13 +1454,14 @@ function resolveAssistantCronNotificationResponsePolicy(job) {
 }
 function resolveAssistantCronNotificationTurnPolicy(job) {
     const policy = resolveAssistantCronBackgroundMaintenancePolicy(job);
-    return policy
-        ? {
+    if (policy) {
+        return {
             kind: 'maintenance-exact-skip',
             maintenanceProfile: policy.profile,
             privateSummary: policy.privateSummary,
-        }
-        : null;
+        };
+    }
+    return null;
 }
 function assistantCronDeviceActivitySkipConsumesOccurrence(input) {
     return (input.decision?.kind === 'skip' &&
@@ -1436,6 +1731,8 @@ async function resolveDeviceActivityParentAuthority(input) {
     if (input.job.kind !== 'local') {
         return {
             assistantTargetOverride: null,
+            automationId: null,
+            contextReferences: [],
             error: null,
             route: null,
         };
@@ -1444,6 +1741,8 @@ async function resolveDeviceActivityParentAuthority(input) {
     if (!metadata) {
         return {
             assistantTargetOverride: null,
+            automationId: null,
+            contextReferences: [],
             error: null,
             route: null,
         };
@@ -1465,6 +1764,8 @@ async function resolveDeviceActivityParentAuthority(input) {
     if (!parentAutomation || parentAutomation.status !== 'active') {
         return {
             assistantTargetOverride: null,
+            automationId: null,
+            contextReferences: [],
             error: ASSISTANT_DEVICE_ACTIVITY_AUTHORITY_STALE_ERROR,
             route: null,
         };
@@ -1472,6 +1773,8 @@ async function resolveDeviceActivityParentAuthority(input) {
     if (parentAutomation.schedule.kind !== 'deviceActivity') {
         return {
             assistantTargetOverride: null,
+            automationId: null,
+            contextReferences: [],
             error: ASSISTANT_DEVICE_ACTIVITY_AUTHORITY_STALE_ERROR,
             route: null,
         };
@@ -1490,12 +1793,16 @@ async function resolveDeviceActivityParentAuthority(input) {
         !assistantCronTargetMatchesAutomationRoute(input.job.job.target, parentAutomation.route)) {
         return {
             assistantTargetOverride: null,
+            automationId: null,
+            contextReferences: [],
             error: ASSISTANT_DEVICE_ACTIVITY_AUTHORITY_STALE_ERROR,
             route: null,
         };
     }
     return {
         assistantTargetOverride: parentAutomation.assistantTargetOverride,
+        automationId: parentAutomation.automationId,
+        contextReferences: [...(parentAutomation.contextReferences ?? [])],
         error: null,
         route: parentAutomation.route,
     };
@@ -1541,31 +1848,27 @@ function resolveStaleAssistantCronNotificationError(input) {
     if (input.job.job.scheduledLog) {
         return null;
     }
-    const nowMs = Date.parse(input.nowIso);
-    const occurrenceMs = Date.parse(input.occurrenceAt);
-    if (!Number.isFinite(nowMs) || !Number.isFinite(occurrenceMs)) {
-        return null;
-    }
-    if (assistantCronHasOpenFiniteOneShotActiveWindow(input.job, nowMs)) {
-        return null;
-    }
-    const ageMs = nowMs - occurrenceMs;
-    if (ageMs <= ASSISTANT_CRON_NOTIFICATION_EXPIRES_AFTER_MS) {
+    const now = new Date(input.nowIso);
+    const deliverable = input.job.kind === 'canonical'
+        ? isCanonicalAssistantCronNotificationOccurrenceDeliverable({
+            now,
+            occurrenceAt: input.occurrenceAt,
+            source: input.job.source,
+        })
+        : isAssistantCronNotificationOccurrenceFresh({
+            now,
+            occurrenceAt: input.occurrenceAt,
+        });
+    if (deliverable) {
         return null;
     }
+    const ageMs = now.getTime() - Date.parse(input.occurrenceAt);
     const lateMinutes = Math.floor(ageMs / 60_000);
     return {
         latenessMinutes: lateMinutes,
         message: `${ASSISTANT_CRON_NOTIFICATION_EXPIRED_ERROR} Scheduled occurrence was ${lateMinutes} minute(s) late.`,
     };
 }
-function assistantCronHasOpenFiniteOneShotActiveWindow(job, nowMs) {
-    return (job.kind === 'canonical' &&
-        job.source.kind === 'automation' &&
-        job.source.schedule.kind === 'at' &&
-        job.source.activeUntil !== null &&
-        nowMs < Date.parse(job.source.activeUntil));
-}
 function emitAssistantCronOccurrenceExpiredEvent(input) {
     const automationSlug = resolveAssistantCronAutomationSlug(input.job);
     if (!automationSlug) {
@@ -1697,6 +2000,7 @@ async function resolveAssistantCronManagedOwnerAuthorization(input) {
     else {
         authorizedDelivery = {
             conversationThreadId: null,
+            deliveryPosture: null,
             externalThreadRouteAuthority: null,
             route: declaredRoute,
         };
@@ -1759,6 +2063,7 @@ async function resolveAssistantCronAuthorizedNotificationDeliveryRoute(input) {
     if (assistantCronExecutionDeliveryTargetProfile(input) !== 'hosted') {
         return {
             conversationThreadId: null,
+            deliveryPosture: null,
             externalThreadRouteAuthority: null,
             route,
         };
@@ -1784,6 +2089,7 @@ async function resolveAssistantCronAuthorizedNotificationDeliveryRoute(input) {
         }
         return {
             conversationThreadId: null,
+            deliveryPosture: null,
             externalThreadRouteAuthority: authority,
             route,
         };
@@ -1791,6 +2097,7 @@ async function resolveAssistantCronAuthorizedNotificationDeliveryRoute(input) {
     if (input.target.channel !== 'linq') {
         return {
             conversationThreadId: null,
+            deliveryPosture: null,
             externalThreadRouteAuthority: null,
             route,
         };
@@ -1809,11 +2116,17 @@ async function resolveAssistantCronAuthorizedNotificationDeliveryRoute(input) {
         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({
+        fromPhoneNumber: input.target.deliverySource?.kind === 'linq'
+            ? input.target.deliverySource.fromPhoneNumber
+            : null,
         homeRouteFallbackAllowed: route.threadIsDirect !== false,
         signal: input.signal,
         target,
         targetKind,
     });
+    if (authority.deliveryBlockCode) {
+        throw new AssistantCronLinqHealthPreflightBlockedError(authority.deliveryBlockCode);
+    }
     const authorizedTarget = normalizeNullableString(authority.target);
     const conversationThreadId = normalizeNullableString(authority.conversationThreadId);
     if (!authorizedTarget || typeof authority.threadIsDirect !== 'boolean') {
@@ -1832,6 +2145,7 @@ async function resolveAssistantCronAuthorizedNotificationDeliveryRoute(input) {
         : null;
     return {
         conversationThreadId,
+        deliveryPosture: authority.deliveryPosture ?? null,
         externalThreadRouteAuthority: null,
         route: {
             bindingDelivery,
@@ -1840,6 +2154,11 @@ async function resolveAssistantCronAuthorizedNotificationDeliveryRoute(input) {
         },
     };
 }
+class AssistantCronLinqHealthPreflightBlockedError extends VaultCliError {
+    constructor(blockCode) {
+        super(`ASSISTANT_LINQ_EGRESS_${blockCode.toUpperCase()}`, 'Scheduled Linq delivery skipped by current line or chat health.');
+    }
+}
 class AssistantCronForegroundYieldedError extends VaultCliError {
     constructor(jobName) {
         super('ASSISTANT_CRON_FOREGROUND_YIELDED', `Assistant cron job "${jobName}" yielded to fresh foreground input.`);
@@ -1857,6 +2176,9 @@ class AssistantCronLifecycleNotificationInvalidatedError extends VaultCliError {
         super('ASSISTANT_CRON_LIFECYCLE_AUTHORITY_STALE', reason);
     }
 }
+function buildAssistantCronOnboardingFollowupReconciliationRequiredError() {
+    return new VaultCliError('ASSISTANT_CRON_ONBOARDING_FOLLOWUP_RECONCILIATION_REQUIRED', ASSISTANT_CRON_ONBOARDING_FOLLOWUP_RECONCILIATION_REQUIRED_ERROR, { retryable: true });
+}
 class AssistantCronManagedOwnerInvalidatedError extends VaultCliError {
     constructor() {
         super('ASSISTANT_CRON_MANAGED_OWNER_SCOPE_STALE', ASSISTANT_CRON_MANAGED_OWNER_SCOPE_MISMATCH_ERROR);