@elizaos/ui 2.0.0-alpha.534 → 2.0.0-alpha.537

package/apps/app-lifeops/src/lifeops/service-mixin-reminders.js

@@ -1,4 +1,10 @@
-// @ts-nocheck — mixin: type safety is enforced on the composed class
+// @ts-nocheck — Mixin pattern: each `withFoo()` returns a class that calls
+// methods belonging to sibling mixins (e.g. `this.recordScreenTimeEvent`).
+// Type checking each mixin in isolation surfaces 700+ phantom errors because
+// the local TBase constraint can't see sibling mixin methods. Real type
+// safety is enforced at the composed-service level (LifeOpsService class).
+// Refactoring requires either declaration-merging every cross-mixin method
+// or moving to a single composed interface — tracked as separate work.
 import crypto from "node:crypto";
 import { loadOwnerContactRoutingHints, loadOwnerContactsConfig, resolveOwnerContactWithFallback, } from "@elizaos/agent/config/owner-contacts";
 import { registerEscalationChannel } from "@elizaos/agent/services/escalation";
@@ -17,10 +23,10 @@ import { createLifeOpsActivitySignal, createLifeOpsChannelPolicy, createLifeOpsR
 import { refreshLifeOpsScheduleInsight } from "./schedule-insight.js";
 import { deriveLocalScheduleObservations, isFreshCloudMergedState, mergeScheduleObservations, preferEffectiveMergedState, recordsFromSyncRequest, resolveScheduleDeviceIdentity, SCHEDULE_CLOUD_SYNC_TTL_MS, SCHEDULE_OBSERVATION_LOOKBACK_MS, } from "./schedule-state.js";
 import { LIFEOPS_SCHEDULE_DEVICE_KINDS, } from "./schedule-sync-contracts.js";
-import { REMINDER_ESCALATION_DELAYS, REMINDER_REVIEW_AFTER_MINUTES_METADATA_KEY, REMINDER_REVIEW_AT_METADATA_KEY, REMINDER_REVIEW_DECISION_METADATA_KEY, REMINDER_REVIEW_ESCALATED_AT_METADATA_KEY, REMINDER_REVIEW_ESCALATED_ATTEMPT_ID_METADATA_KEY, REMINDER_REVIEW_ESCALATED_CHANNEL_METADATA_KEY, REMINDER_REVIEW_REASON_METADATA_KEY, REMINDER_REVIEW_RESPONDED_AT_METADATA_KEY, REMINDER_REVIEW_RESPONSE_TEXT_METADATA_KEY, REMINDER_REVIEW_STATUS_METADATA_KEY, } from "./service-constants.js";
-import { isReminderChannelAllowedForUrgency, isWithinQuietHours as isWithinQuietHoursPolicy, } from "./service-helpers-misc.js";
+import { DEFAULT_REMINDER_INTENSITY, DEFAULT_REMINDER_PROCESS_LIMIT, DEFAULT_WORKFLOW_PROCESS_LIMIT, GLOBAL_REMINDER_PREFERENCE_CHANNEL_REF, OVERVIEW_HORIZON_MINUTES, PROACTIVE_TASK_QUERY_TAGS, REMINDER_ESCALATION_ACTIVITY_ACTIVE_METADATA_KEY, REMINDER_ESCALATION_ACTIVITY_PLATFORM_METADATA_KEY, REMINDER_ESCALATION_CHANNELS_METADATA_KEY, REMINDER_ESCALATION_INDEX_METADATA_KEY, REMINDER_ESCALATION_LAST_ATTEMPT_AT_METADATA_KEY, REMINDER_ESCALATION_LAST_CHANNEL_METADATA_KEY, REMINDER_ESCALATION_LAST_OUTCOME_METADATA_KEY, REMINDER_ESCALATION_REASON_METADATA_KEY, REMINDER_ESCALATION_RESOLUTION_METADATA_KEY, REMINDER_ESCALATION_RESOLUTION_NOTE_METADATA_KEY, REMINDER_ESCALATION_RESOLVED_AT_METADATA_KEY, REMINDER_ESCALATION_STARTED_AT_METADATA_KEY, REMINDER_INTENSITY_METADATA_KEY, REMINDER_INTENSITY_NOTE_METADATA_KEY, REMINDER_INTENSITY_UPDATED_AT_METADATA_KEY, REMINDER_LIFECYCLE_METADATA_KEY, REMINDER_PREFERENCE_SCOPE_METADATA_KEY, REMINDER_REVIEW_AFTER_MINUTES_METADATA_KEY, REMINDER_REVIEW_AT_METADATA_KEY, REMINDER_REVIEW_DECISION_METADATA_KEY, REMINDER_REVIEW_ESCALATED_AT_METADATA_KEY, REMINDER_REVIEW_ESCALATED_ATTEMPT_ID_METADATA_KEY, REMINDER_REVIEW_ESCALATED_CHANNEL_METADATA_KEY, REMINDER_REVIEW_REASON_METADATA_KEY, REMINDER_REVIEW_RESPONDED_AT_METADATA_KEY, REMINDER_REVIEW_RESPONSE_TEXT_METADATA_KEY, REMINDER_REVIEW_STATUS_METADATA_KEY, } from "./service-constants.js";
+import { buildActiveReminders, isReminderChannelAllowedForUrgency, isWithinQuietHours as isWithinQuietHoursPolicy, } from "./service-helpers-misc.js";
 import { computeDefinitionPerformance } from "./service-helpers-occurrence.js";
-import { classifyReminderOwnerResponseText, rankReminderEscalationChannels, readReminderAttemptLifecycle, resolveReminderDeliveryUrgency, resolveReminderEscalationDelayMinutes, shouldDeferReminderUntilComputerActive, shouldDeliverReminderForIntensity, shouldEscalateImmediately, } from "./service-helpers-reminder.js";
+import { applyReminderIntensityToPlan, buildReminderResponseClaim, classifyReminderOwnerResponseText, decideReminderReviewTransition, isReminderReviewClosed, normalizeReminderIntensityInput, rankReminderEscalationChannelCandidates, readReminderAttemptLifecycle, readReminderPreferenceSettingFromMetadata, readReminderReviewAt, resolveReminderDeliveryUrgency, resolveReminderEscalationDelayMinutes, resolveReminderEscalationRoutingPolicy, resolveReminderReviewDelayMinutes, shouldDeferReminderUntilComputerActive, shouldDeliverReminderForIntensity, shouldEscalateImmediately, withReminderPreferenceMetadata, } from "./service-helpers-reminder.js";
 import { fail, lifeOpsErrorMessage, normalizeEnumValue, normalizeOptionalString, requireNonEmptyString, } from "./service-normalize.js";
 import { normalizeHealthSignal } from "./service-normalize-health.js";
 import { deriveSleepWakeEvents, } from "./sleep-wake-events.js";
@@ -107,32 +113,6 @@ export function buildReminderEnforcementState(now, timezone, definition, twilioV
     };
 }
 // ---------------------------------------------------------------------------
-// Local constants
-// ---------------------------------------------------------------------------
-const DEFAULT_REMINDER_PROCESS_LIMIT = 24;
-const DEFAULT_WORKFLOW_PROCESS_LIMIT = 12;
-const OVERVIEW_HORIZON_MINUTES = 18 * 60;
-const DEFAULT_REMINDER_INTENSITY = "normal";
-const GLOBAL_REMINDER_PREFERENCE_CHANNEL_REF = "lifeops://owner/reminder-preferences";
-const REMINDER_INTENSITY_METADATA_KEY = "reminderIntensity";
-const REMINDER_INTENSITY_UPDATED_AT_METADATA_KEY = "reminderIntensityUpdatedAt";
-const REMINDER_INTENSITY_NOTE_METADATA_KEY = "reminderIntensityNote";
-const REMINDER_PREFERENCE_SCOPE_METADATA_KEY = "reminderPreferenceScope";
-const REMINDER_LIFECYCLE_METADATA_KEY = "lifecycle";
-const REMINDER_ESCALATION_INDEX_METADATA_KEY = "escalationIndex";
-const REMINDER_ESCALATION_REASON_METADATA_KEY = "escalationReason";
-const REMINDER_ESCALATION_ACTIVITY_PLATFORM_METADATA_KEY = "activityPlatform";
-const REMINDER_ESCALATION_ACTIVITY_ACTIVE_METADATA_KEY = "activityActive";
-const REMINDER_ESCALATION_STARTED_AT_METADATA_KEY = "reminderEscalationStartedAt";
-const REMINDER_ESCALATION_LAST_ATTEMPT_AT_METADATA_KEY = "reminderEscalationLastAttemptAt";
-const REMINDER_ESCALATION_LAST_CHANNEL_METADATA_KEY = "reminderEscalationLastChannel";
-const REMINDER_ESCALATION_LAST_OUTCOME_METADATA_KEY = "reminderEscalationLastOutcome";
-const REMINDER_ESCALATION_CHANNELS_METADATA_KEY = "reminderEscalationChannels";
-const REMINDER_ESCALATION_RESOLVED_AT_METADATA_KEY = "reminderEscalationResolvedAt";
-const REMINDER_ESCALATION_RESOLUTION_METADATA_KEY = "reminderEscalationResolution";
-const REMINDER_ESCALATION_RESOLUTION_NOTE_METADATA_KEY = "reminderEscalationResolutionNote";
-const PROACTIVE_TASK_QUERY_TAGS = ["queue", "repeat", "proactive"];
-// ---------------------------------------------------------------------------
 // Local helpers (copied from service.ts)
 // ---------------------------------------------------------------------------
 function isRecord(value) {
@@ -226,25 +206,6 @@ const LIFEOPS_OWNER_CONTACTS_LOAD_CONTEXT = {
     envPrefix: "LIFEOPS_OWNER_",
 };
 // Reminder-specific helpers
-const REMINDER_INTENSITY_CANONICAL_ALIASES = {
-    minimal: "minimal",
-    normal: "normal",
-    persistent: "persistent",
-    high_priority_only: "high_priority_only",
-    paused: "high_priority_only",
-    low: "minimal",
-    high: "persistent",
-};
-function normalizeReminderIntensityInput(value, field) {
-    if (typeof value !== "string" || value.trim().length === 0) {
-        fail(400, `${field} must be a non-empty string`);
-    }
-    const canonical = REMINDER_INTENSITY_CANONICAL_ALIASES[value.trim().toLowerCase()];
-    if (!canonical) {
-        fail(400, `${field} must be one of: ${Object.keys(REMINDER_INTENSITY_CANONICAL_ALIASES).join(", ")}`);
-    }
-    return canonical;
-}
 function isReminderChannel(value) {
     return (typeof value === "string" &&
         (value === "in_app" ||
@@ -263,20 +224,8 @@ function isDeliveredReminderOutcome(outcome) {
         outcome === "delivered_read" ||
         outcome === "delivered_unread");
 }
-function readReminderReviewAt(attempt) {
-    const value = attempt.deliveryMetadata?.[REMINDER_REVIEW_AT_METADATA_KEY];
-    if (typeof value !== "string") {
-        return null;
-    }
-    return Number.isFinite(Date.parse(value)) ? value : null;
-}
-function readReminderReviewStatus(attempt) {
-    const value = attempt.deliveryMetadata?.[REMINDER_REVIEW_STATUS_METADATA_KEY] ?? null;
-    return typeof value === "string" && value.trim().length > 0 ? value : null;
-}
-function isReminderReviewClosed(attempt) {
-    const status = readReminderReviewStatus(attempt);
-    return status === "resolved" || status === "escalated";
+function buildReminderSnoozeClarificationBody(title) {
+    return `I can snooze "${title}", but I need a clear time first. Reply with something like "30 minutes", "1 hour", "tonight", or "tomorrow morning".`;
 }
 function readReminderAttemptAnchorMs(attempt) {
     const attempted = attempt.attemptedAt ? Date.parse(attempt.attemptedAt) : NaN;
@@ -295,40 +244,6 @@ function readLatestPendingReminderReviewAttempt(attempts) {
         readReminderAttemptAnchorMs(right))
         .at(-1) ?? null);
 }
-function readReminderPreferenceSettingFromMetadata(metadata, source) {
-    if (!metadata)
-        return null;
-    const intensity = metadata[REMINDER_INTENSITY_METADATA_KEY];
-    if (typeof intensity !== "string")
-        return null;
-    const canonical = REMINDER_INTENSITY_CANONICAL_ALIASES[intensity];
-    if (!canonical)
-        return null;
-    return {
-        intensity: canonical,
-        source,
-        updatedAt: typeof metadata[REMINDER_INTENSITY_UPDATED_AT_METADATA_KEY] === "string"
-            ? metadata[REMINDER_INTENSITY_UPDATED_AT_METADATA_KEY]
-            : null,
-        note: typeof metadata[REMINDER_INTENSITY_NOTE_METADATA_KEY] === "string"
-            ? metadata[REMINDER_INTENSITY_NOTE_METADATA_KEY]
-            : null,
-    };
-}
-function withReminderPreferenceMetadata(metadata, intensity, updatedAt, note, _scope) {
-    return {
-        ...metadata,
-        [REMINDER_INTENSITY_METADATA_KEY]: intensity,
-        [REMINDER_INTENSITY_UPDATED_AT_METADATA_KEY]: updatedAt,
-        [REMINDER_INTENSITY_NOTE_METADATA_KEY]: note,
-    };
-}
-function applyReminderIntensityToPlan(plan, intensity) {
-    if (intensity === "normal" || intensity === "persistent") {
-        return plan;
-    }
-    return plan;
-}
 function buildReminderBody(args) {
     const parts = [];
     if (args.lifecycle === "escalation") {
@@ -428,34 +343,6 @@ function collectNearbyReminderTitles(args) {
     }
     return titles;
 }
-function buildActiveReminders(occurrences, plansByDefinitionId, now) {
-    const rows = [];
-    for (const occurrence of occurrences) {
-        const plan = plansByDefinitionId.get(occurrence.definitionId);
-        if (!plan)
-            continue;
-        const anchorIso = occurrence.snoozedUntil ?? occurrence.relevanceStartAt;
-        if (!anchorIso)
-            continue;
-        const anchorDate = new Date(anchorIso);
-        for (const [stepIndex, step] of plan.steps.entries()) {
-            const scheduledFor = addMinutes(anchorDate, step.offsetMinutes).toISOString();
-            if (Date.parse(scheduledFor) > now.getTime())
-                continue;
-            rows.push({
-                ownerType: "occurrence",
-                ownerId: occurrence.id,
-                occurrenceId: occurrence.id,
-                definitionId: occurrence.definitionId,
-                title: occurrence.title,
-                channel: step.channel,
-                stepIndex,
-                scheduledFor,
-            });
-        }
-    }
-    return rows;
-}
 function buildActiveCalendarEventReminders(events, plansByEventId, _ownerEntityId, now) {
     const rows = [];
     for (const event of events) {
@@ -591,6 +478,7 @@ export function withReminders(Base) {
             const noResponse = {
                 decision: "no_response",
                 resolution: null,
+                snoozeRequest: null,
                 respondedAt: null,
                 responseText: null,
                 confidence: 0,
@@ -632,7 +520,8 @@ export function withReminders(Base) {
                     const text = typeof memory.content?.text === "string"
                         ? memory.content.text.trim()
                         : "";
-                    return { createdAt, text };
+                    const roomId = typeof memory.roomId === "string" ? memory.roomId : null;
+                    return { createdAt, roomId, text };
                 })
                     .filter((response) => response.createdAt !== null &&
                     response.createdAt > attemptedMs &&
@@ -642,12 +531,46 @@ export function withReminders(Base) {
                 if (ownerResponses.length === 0) {
                     return noResponse;
                 }
+                const title = typeof args.attempt.deliveryMetadata.title === "string"
+                    ? args.attempt.deliveryMetadata.title
+                    : null;
+                const competingAttempts = args.competingAttempts && args.competingAttempts.length > 0
+                    ? args.competingAttempts
+                    : [args.attempt];
                 for (const response of ownerResponses) {
-                    const classification = classifyReminderOwnerResponseText(response.text);
+                    const responseClaim = buildReminderResponseClaim({
+                        attempt: args.attempt,
+                        competingAttempts,
+                        response: {
+                            text: response.text,
+                            createdAt: response.createdAt,
+                            roomId: response.roomId,
+                        },
+                        roomIds,
+                    });
+                    const classification = classifyReminderOwnerResponseText(response.text, {
+                        title,
+                        attemptedAt,
+                        respondedAt: response.createdAt,
+                        channel: args.attempt.channel,
+                        allowStandaloneResolution: responseClaim.allowStandaloneResolution,
+                    });
                     if (classification.decision === "explicit_resolution") {
                         return {
                             decision: "explicit_resolution",
                             resolution: classification.resolution,
+                            snoozeRequest: classification.snoozeRequest,
+                            respondedAt: new Date(response.createdAt).toISOString(),
+                            responseText: response.text,
+                            confidence: classification.confidence,
+                            reason: classification.reason,
+                        };
+                    }
+                    if (classification.decision === "needs_clarification") {
+                        return {
+                            decision: "needs_clarification",
+                            resolution: null,
+                            snoozeRequest: null,
                             respondedAt: new Date(response.createdAt).toISOString(),
                             responseText: response.text,
                             confidence: classification.confidence,
@@ -659,6 +582,7 @@ export function withReminders(Base) {
                 return {
                     decision: "unrelated",
                     resolution: null,
+                    snoozeRequest: null,
                     respondedAt: latest ? new Date(latest.createdAt).toISOString() : null,
                     responseText: latest?.text ?? null,
                     confidence: 0.4,
@@ -1394,7 +1318,7 @@ export function withReminders(Base) {
                 },
             };
         }
-        async readReminderActivityProfileSnapshot() {
+        async readLifeOpsAttentionContext() {
             try {
                 const schedule = await this.refreshEffectiveScheduleState({
                     timezone: resolveDefaultTimeZone(),
@@ -1415,7 +1339,27 @@ export function withReminders(Base) {
                 if (!isRecord(profile) && !schedule) {
                     return null;
                 }
+                const profileLastSeenAt = isRecord(profile) && typeof profile.lastSeenAt === "number"
+                    ? profile.lastSeenAt
+                    : null;
+                const scheduleLastSeenAt = schedule?.lastActiveAt
+                    ? Date.parse(schedule.lastActiveAt)
+                    : null;
+                const lastSeenAt = profileLastSeenAt ?? scheduleLastSeenAt;
                 return {
+                    source: isRecord(profile) && schedule
+                        ? "mixed"
+                        : isRecord(profile)
+                            ? "proactive_activity_profile"
+                            : schedule
+                                ? "schedule_state"
+                                : "unknown",
+                    capturedAt: new Date().toISOString(),
+                    sourceFreshnessMs: lastSeenAt !== null ? Math.max(0, Date.now() - lastSeenAt) : null,
+                    sourceConfidence: schedule?.stateConfidence ?? null,
+                    privacyMode: "unknown",
+                    socialContext: "unknown",
+                    locationSafety: "unknown",
                     primaryPlatform: isRecord(profile)
                         ? (normalizeOptionalString(profile.primaryPlatform) ?? null)
                         : null,
@@ -1426,17 +1370,38 @@ export function withReminders(Base) {
                         ? (normalizeOptionalString(profile.lastSeenPlatform) ?? null)
                         : null,
                     isCurrentlyActive: isRecord(profile) && profile.isCurrentlyActive === true,
-                    lastSeenAt: isRecord(profile) && typeof profile.lastSeenAt === "number"
-                        ? profile.lastSeenAt
-                        : schedule?.lastActiveAt
-                            ? Date.parse(schedule.lastActiveAt)
-                            : null,
+                    lastSeenAt,
                     circadianState: schedule?.circadianState ?? "unclear",
                     stateConfidence: schedule?.stateConfidence ?? 0,
                     lastSleepEndedAt: schedule?.lastSleepEndedAt ?? null,
                     nextMealLabel: schedule?.nextMealLabel ?? null,
                     nextMealWindowStartAt: schedule?.nextMealWindowStartAt ?? null,
                     nextMealWindowEndAt: schedule?.nextMealWindowEndAt ?? null,
+                    calendarBusy: isRecord(profile) && profile.calendarBusy === true,
+                    dndActive: isRecord(profile) && profile.dndActive === true,
+                    hasCalendarData: isRecord(profile) && typeof profile.hasCalendarData === "boolean"
+                        ? profile.hasCalendarData
+                        : false,
+                    avgWeekdayMeetings: isRecord(profile) && typeof profile.avgWeekdayMeetings === "number"
+                        ? profile.avgWeekdayMeetings
+                        : null,
+                    hasOpenActivityCycle: isRecord(profile) && profile.hasOpenActivityCycle === true,
+                    currentActivityCycleStartedAt: isRecord(profile) &&
+                        typeof profile.currentActivityCycleStartedAt === "number"
+                        ? profile.currentActivityCycleStartedAt
+                        : null,
+                    screenContextFocus: isRecord(profile) &&
+                        typeof profile.screenContextFocus === "string" &&
+                        ["work", "leisure", "transition", "idle", "unknown"].includes(profile.screenContextFocus)
+                        ? profile.screenContextFocus
+                        : null,
+                    screenContextBusy: isRecord(profile) && profile.screenContextBusy === true,
+                    screenContextAvailable: isRecord(profile) && profile.screenContextAvailable === true,
+                    screenContextStale: isRecord(profile) && profile.screenContextStale === true,
+                    screenContextConfidence: isRecord(profile) &&
+                        typeof profile.screenContextConfidence === "number"
+                        ? profile.screenContextConfidence
+                        : null,
                 };
             }
             catch (error) {
@@ -1446,6 +1411,9 @@ export function withReminders(Base) {
                 return null;
             }
         }
+        async readReminderActivityProfileSnapshot() {
+            return this.readLifeOpsAttentionContext();
+        }
         /**
          * Scan recent "delivered" attempts and upgrade to "delivered_read" when the
          * owner was seen active after the reminder was sent. This gives escalation
@@ -1519,52 +1487,127 @@ export function withReminders(Base) {
             }
             return rows;
         }
-        async resolveReminderEscalationChannels(args) {
-            const ordered = [];
+        async resolveReminderEscalationRouteCandidates(args) {
+            const candidates = [];
             const ownerContacts = loadOwnerContactsConfig(LIFEOPS_OWNER_CONTACTS_LOAD_CONTEXT);
             const ownerContactHints = await loadOwnerContactRoutingHints(this.runtime, ownerContacts);
-            const pushChannel = async (channel) => {
-                if (!channel || ordered.includes(channel)) {
+            const nowMs = Date.now();
+            const failureCooldownMs = 6 * 60 * 60_000;
+            const hasRecentChannelFailure = (channel) => (args.attempts ?? []).some((attempt) => {
+                if (attempt.channel !== channel) {
+                    return false;
+                }
+                if (attempt.outcome !== "blocked_connector" &&
+                    attempt.outcome !== "blocked_policy") {
+                    return false;
+                }
+                const attemptedMs = attempt.attemptedAt
+                    ? Date.parse(attempt.attemptedAt)
+                    : Number.NaN;
+                return (Number.isFinite(attemptedMs) &&
+                    nowMs - attemptedMs <= failureCooldownMs);
+            });
+            const policyWeightAdjustments = {};
+            for (const policy of args.policies) {
+                const channel = isReminderChannel(policy.channelType)
+                    ? policy.channelType
+                    : null;
+                if (!channel)
+                    continue;
+                const weight = policy.metadata.routingWeight;
+                if (typeof weight === "number" && Number.isFinite(weight)) {
+                    policyWeightAdjustments[channel] =
+                        (policyWeightAdjustments[channel] ?? 0) + weight;
+                }
+            }
+            const evaluateCandidate = async (candidate) => {
+                if (!candidate ||
+                    candidates.some((resolvedCandidate) => {
+                        return resolvedCandidate.channel === candidate.channel;
+                    })) {
                     return;
                 }
+                const vetoReasons = [];
+                const channel = candidate.channel;
                 if (!isReminderChannelAllowedForUrgency(channel, args.urgency)) {
+                    vetoReasons.push("urgency_policy");
+                }
+                if (args.urgency !== "critical" && hasRecentChannelFailure(channel)) {
+                    vetoReasons.push("recent_channel_failure");
+                }
+                if (channel !== "in_app" &&
+                    routingPolicy.interruptionBudget === "low") {
+                    vetoReasons.push("attention_budget_low");
+                }
+                if (vetoReasons.length > 0) {
+                    candidates.push({ ...candidate, vetoReasons });
                     return;
                 }
                 if (channel === "in_app") {
-                    ordered.push(channel);
+                    candidates.push({ ...candidate, vetoReasons });
                     return;
                 }
                 const policy = await this.resolvePrimaryChannelPolicy(channel);
                 if (policy) {
+                    if (policy.metadata.disableReminderRouting === true) {
+                        vetoReasons.push("channel_policy_disabled");
+                        candidates.push({ ...candidate, vetoReasons });
+                        return;
+                    }
                     if (!policy.allowReminders || !policy.allowEscalation) {
+                        vetoReasons.push("channel_policy_blocks_escalation");
+                        candidates.push({ ...candidate, vetoReasons });
                         return;
                     }
                 }
                 else if (channel === "sms" || channel === "voice") {
+                    vetoReasons.push("missing_required_direct_policy");
+                    candidates.push({ ...candidate, vetoReasons });
                     return;
                 }
                 if (channel === "sms" || channel === "voice") {
-                    ordered.push(channel);
+                    candidates.push({ ...candidate, vetoReasons });
                     return;
                 }
                 if (typeof this.runtime.sendMessageToTarget !== "function") {
+                    vetoReasons.push("runtime_target_send_unavailable");
+                    candidates.push({ ...candidate, vetoReasons });
                     return;
                 }
                 const runtimeTarget = await this.resolveRuntimeReminderTarget(channel, policy, ownerContacts, ownerContactHints);
                 if (runtimeTarget !== null) {
-                    ordered.push(channel);
+                    candidates.push({ ...candidate, vetoReasons });
+                }
+                else {
+                    candidates.push({
+                        ...candidate,
+                        vetoReasons: ["runtime_target_missing"],
+                    });
                 }
             };
-            const rankedChannels = rankReminderEscalationChannels({
+            const routingPolicy = resolveReminderEscalationRoutingPolicy({
+                activityProfile: args.activityProfile,
+                urgency: args.urgency,
+            });
+            const rankedCandidates = rankReminderEscalationChannelCandidates({
                 activityProfile: args.activityProfile,
                 ownerContactHints,
                 ownerContactSources: Object.keys(ownerContacts),
                 policyChannels: args.policies.map((policy) => policy.channelType),
+                policyChannelWeightAdjustments: policyWeightAdjustments,
+                urgency: args.urgency,
+                routingPolicy,
             });
-            for (const channel of rankedChannels) {
-                await pushChannel(channel);
+            for (const candidate of rankedCandidates) {
+                await evaluateCandidate(candidate);
             }
-            return ordered;
+            return candidates;
+        }
+        async resolveReminderEscalationChannels(args) {
+            const candidates = await this.resolveReminderEscalationRouteCandidates(args);
+            return candidates
+                .filter((candidate) => candidate.vetoReasons.length === 0)
+                .map((candidate) => candidate.channel);
         }
         async markReminderEscalationStarted(args) {
             if (args.ownerType === "occurrence") {
@@ -1682,6 +1725,18 @@ export function withReminders(Base) {
             });
         }
         async resolveReminderReviewFromOwnerResponse(args) {
+            if (args.resolution === "snoozed") {
+                if (args.ownerType !== "occurrence" || !args.snoozeRequest) {
+                    await this.markReminderReviewObservedResponse({
+                        attempt: args.attempt,
+                        decision: "needs_clarification",
+                        respondedAt: args.respondedAt,
+                        responseText: args.responseText,
+                        reason: "snooze_resolution_missing_reschedulable_occurrence",
+                    });
+                    return;
+                }
+            }
             const reviewMetadata = {
                 [REMINDER_REVIEW_STATUS_METADATA_KEY]: "resolved",
                 [REMINDER_REVIEW_DECISION_METADATA_KEY]: args.resolution,
@@ -1690,10 +1745,19 @@ export function withReminders(Base) {
                 reviewConfidence: args.confidence,
                 reviewReason: args.reason,
             };
-            await this.repository.updateReminderAttemptOutcome(args.attempt.id, args.attempt.outcome, reviewMetadata);
             const acknowledgementNote = args.responseText
                 ? `Owner replied: ${args.responseText}`
                 : args.reason;
+            if (args.resolution === "snoozed") {
+                await this.snoozeOccurrence(args.ownerId, args.snoozeRequest, new Date(args.respondedAt ?? args.reviewedAt));
+                await this.repository.updateReminderAttemptOutcome(args.attempt.id, args.attempt.outcome, reviewMetadata);
+                Object.assign(args.attempt.deliveryMetadata, reviewMetadata);
+                args.attempt.reviewStatus = "resolved";
+                return;
+            }
+            await this.repository.updateReminderAttemptOutcome(args.attempt.id, args.attempt.outcome, reviewMetadata);
+            Object.assign(args.attempt.deliveryMetadata, reviewMetadata);
+            args.attempt.reviewStatus = "resolved";
             if (args.ownerType === "occurrence") {
                 const occurrence = await this.repository.getOccurrence(this.agentId(), args.ownerId);
                 if (occurrence) {
@@ -1732,23 +1796,205 @@ export function withReminders(Base) {
                 note: acknowledgementNote,
             });
         }
+        async markReminderReviewResolvedFromState(args) {
+            const reviewMetadata = {
+                [REMINDER_REVIEW_STATUS_METADATA_KEY]: "resolved",
+                [REMINDER_REVIEW_DECISION_METADATA_KEY]: args.resolution,
+                reviewReason: args.reason,
+            };
+            await this.repository.updateReminderAttemptOutcome(args.attempt.id, args.attempt.outcome, reviewMetadata);
+            Object.assign(args.attempt.deliveryMetadata, reviewMetadata);
+            args.attempt.reviewStatus = "resolved";
+            await this.resolveReminderEscalation({
+                ownerType: args.ownerType,
+                ownerId: args.ownerId,
+                resolvedAt: args.resolvedAt,
+                resolution: args.resolution,
+                note: args.reason,
+            });
+        }
         async markReminderReviewEscalated(args) {
-            await this.repository.updateReminderAttemptOutcome(args.attempt.id, args.attempt.outcome, {
+            const reviewMetadata = {
                 [REMINDER_REVIEW_STATUS_METADATA_KEY]: "escalated",
                 [REMINDER_REVIEW_DECISION_METADATA_KEY]: "escalate",
                 [REMINDER_REVIEW_ESCALATED_AT_METADATA_KEY]: args.escalatedAt,
                 [REMINDER_REVIEW_ESCALATED_ATTEMPT_ID_METADATA_KEY]: args.escalatedAttempt.id,
                 [REMINDER_REVIEW_ESCALATED_CHANNEL_METADATA_KEY]: args.escalatedAttempt.channel,
-            });
+            };
+            await this.repository.updateReminderAttemptOutcome(args.attempt.id, args.attempt.outcome, reviewMetadata);
+            Object.assign(args.attempt.deliveryMetadata, reviewMetadata);
+            args.attempt.reviewStatus = "escalated";
+        }
+        async markReminderReviewClarificationRequested(args) {
+            const reviewMetadata = {
+                [REMINDER_REVIEW_STATUS_METADATA_KEY]: "clarification_requested",
+                [REMINDER_REVIEW_DECISION_METADATA_KEY]: "clarify",
+                [REMINDER_REVIEW_ESCALATED_AT_METADATA_KEY]: args.requestedAt,
+                [REMINDER_REVIEW_ESCALATED_ATTEMPT_ID_METADATA_KEY]: args.clarificationAttempt.id,
+                [REMINDER_REVIEW_ESCALATED_CHANNEL_METADATA_KEY]: args.clarificationAttempt.channel,
+            };
+            await this.repository.updateReminderAttemptOutcome(args.attempt.id, args.attempt.outcome, reviewMetadata);
+            Object.assign(args.attempt.deliveryMetadata, reviewMetadata);
+            args.attempt.reviewStatus = "clarification_requested";
         }
         async markReminderReviewObservedResponse(args) {
-            await this.repository.updateReminderAttemptOutcome(args.attempt.id, args.attempt.outcome, {
+            const reviewMetadata = {
                 [REMINDER_REVIEW_STATUS_METADATA_KEY]: args.decision,
                 [REMINDER_REVIEW_DECISION_METADATA_KEY]: args.decision,
                 [REMINDER_REVIEW_RESPONDED_AT_METADATA_KEY]: args.respondedAt,
                 [REMINDER_REVIEW_RESPONSE_TEXT_METADATA_KEY]: args.responseText,
                 reviewReason: args.reason,
-            });
+            };
+            await this.repository.updateReminderAttemptOutcome(args.attempt.id, args.attempt.outcome, reviewMetadata);
+            Object.assign(args.attempt.deliveryMetadata, reviewMetadata);
+            args.attempt.reviewStatus = args.decision;
+        }
+        async processDueReminderReviewJobs(args) {
+            if (args.limit <= 0) {
+                return [];
+            }
+            const nowIso = args.now.toISOString();
+            const dueReviewAttempts = typeof this.repository.claimDueReminderReviewAttempts === "function"
+                ? await this.repository.claimDueReminderReviewAttempts(this.agentId(), nowIso, args.limit, `lifeops:${this.agentId()}`)
+                : await this.repository.listDueReminderReviewAttempts(this.agentId(), nowIso, args.limit);
+            if (dueReviewAttempts.length === 0) {
+                return [];
+            }
+            const allAttempts = [...args.attempts];
+            const attemptsById = new Map(allAttempts.map((attempt) => [attempt.id, attempt]));
+            for (const attempt of dueReviewAttempts) {
+                if (!attemptsById.has(attempt.id)) {
+                    allAttempts.push(attempt);
+                    attemptsById.set(attempt.id, attempt);
+                }
+            }
+            const dispatchedAttempts = [];
+            let calendarEvents = null;
+            for (const dueReviewAttempt of dueReviewAttempts) {
+                const reviewAttempt = attemptsById.get(dueReviewAttempt.id) ?? dueReviewAttempt;
+                if (dispatchedAttempts.length >= args.limit) {
+                    break;
+                }
+                if (isReminderReviewClosed(reviewAttempt)) {
+                    continue;
+                }
+                const plan = await this.repository.getReminderPlan(this.agentId(), reviewAttempt.planId);
+                if (!plan) {
+                    continue;
+                }
+                if (reviewAttempt.ownerType === "occurrence") {
+                    const occurrence = await this.repository.getOccurrenceView(this.agentId(), reviewAttempt.ownerId);
+                    if (!occurrence) {
+                        continue;
+                    }
+                    const stateResolution = occurrence.state === "completed"
+                        ? "completed"
+                        : occurrence.state === "skipped"
+                            ? "skipped"
+                            : occurrence.state === "snoozed"
+                                ? "snoozed"
+                                : occurrence.metadata.reminderAcknowledgedAt
+                                    ? "acknowledged"
+                                    : null;
+                    if (stateResolution) {
+                        await this.markReminderReviewResolvedFromState({
+                            ownerType: "occurrence",
+                            ownerId: occurrence.id,
+                            attempt: reviewAttempt,
+                            resolvedAt: nowIso,
+                            resolution: stateResolution,
+                            reason: `occurrence_state_${occurrence.state}`,
+                        });
+                        continue;
+                    }
+                    const definition = await this.repository.getDefinition(this.agentId(), occurrence.definitionId);
+                    const preference = definition
+                        ? await this.getReminderPreference(definition.id)
+                        : null;
+                    const attempt = await this.dispatchDueReminderEscalation({
+                        plan,
+                        ownerType: "occurrence",
+                        ownerId: occurrence.id,
+                        occurrenceId: occurrence.id,
+                        subjectType: occurrence.subjectType,
+                        title: occurrence.title,
+                        dueAt: occurrence.dueAt,
+                        urgency: resolveReminderDeliveryUrgency({
+                            metadata: occurrence.metadata,
+                            priority: occurrence.priority,
+                        }),
+                        intensity: preference?.effective.intensity ?? args.defaultIntensity,
+                        quietHours: plan.quietHours,
+                        attemptedAt: nowIso,
+                        now: args.now,
+                        attempts: allAttempts,
+                        policies: args.policies,
+                        activityProfile: args.activityProfile,
+                        occurrence,
+                        acknowledged: false,
+                        nearbyReminderTitles: [],
+                        timezone: args.timezone,
+                        definition,
+                        reviewAttempt,
+                    });
+                    if (attempt) {
+                        dispatchedAttempts.push(attempt);
+                        allAttempts.push(attempt);
+                        attemptsById.set(attempt.id, attempt);
+                    }
+                    continue;
+                }
+                if (reviewAttempt.ownerType === "calendar_event") {
+                    calendarEvents ??= await this.repository.listCalendarEvents(this.agentId(), "google");
+                    const event = calendarEvents.find((candidate) => candidate.id === reviewAttempt.ownerId) ?? null;
+                    if (!event) {
+                        continue;
+                    }
+                    if (event.metadata.reminderAcknowledgedAt) {
+                        await this.markReminderReviewResolvedFromState({
+                            ownerType: "calendar_event",
+                            ownerId: event.id,
+                            attempt: reviewAttempt,
+                            resolvedAt: nowIso,
+                            resolution: "acknowledged",
+                            reason: "calendar_event_already_acknowledged",
+                        });
+                        continue;
+                    }
+                    const attempt = await this.dispatchDueReminderEscalation({
+                        plan,
+                        ownerType: "calendar_event",
+                        ownerId: event.id,
+                        occurrenceId: null,
+                        subjectType: "owner",
+                        title: event.title,
+                        dueAt: event.startAt,
+                        urgency: resolveReminderDeliveryUrgency({
+                            metadata: event.metadata,
+                            fallback: "medium",
+                        }),
+                        intensity: args.defaultIntensity,
+                        quietHours: plan.quietHours,
+                        attemptedAt: nowIso,
+                        now: args.now,
+                        attempts: allAttempts,
+                        policies: args.policies,
+                        activityProfile: args.activityProfile,
+                        eventStartAt: event.startAt,
+                        acknowledged: false,
+                        nearbyReminderTitles: [],
+                        timezone: args.timezone,
+                        definition: null,
+                        reviewAttempt,
+                    });
+                    if (attempt) {
+                        dispatchedAttempts.push(attempt);
+                        allAttempts.push(attempt);
+                        attemptsById.set(attempt.id, attempt);
+                    }
+                }
+            }
+            return dispatchedAttempts;
         }
         async dispatchDueReminderEscalation(args) {
             if (!shouldDeliverReminderForIntensity(args.intensity, args.urgency)) {
@@ -1785,7 +2031,8 @@ export function withReminders(Base) {
             const lastScheduledPlanTime = Date.parse(lastScheduledPlanEntry.scheduledFor);
             const nowMs = args.now.getTime();
             const planExhausted = nowMs >= lastScheduledPlanTime;
-            const reviewAttempt = readLatestPendingReminderReviewAttempt(ownerAttempts);
+            const reviewAttempt = args.reviewAttempt ??
+                readLatestPendingReminderReviewAttempt(ownerAttempts);
             const reviewAt = reviewAttempt
                 ? readReminderReviewAt(reviewAttempt)
                 : null;
@@ -1813,7 +2060,8 @@ export function withReminders(Base) {
             }
             const twilioVoiceAvailable = readTwilioCredentialsFromEnv() !== null;
             const enforcementState = buildReminderEnforcementState(args.now, args.timezone, args.definition, twilioVoiceAvailable);
-            let forceVoice = enforcementState?.twilioVoiceAvailable &&
+            let forceVoice = args.urgency === "critical" &&
+                enforcementState?.twilioVoiceAvailable &&
                 enforcementState.definitionIsRoutine &&
                 enforcementState.window.kind !== "none" &&
                 enforcementState.minutesPastStart > 20;
@@ -1824,7 +2072,8 @@ export function withReminders(Base) {
                     return null;
                 }
                 const enforcement = applyEnforcementOverrides(baseDelayMinutes, enforcementState);
-                forceVoice = forceVoice || enforcement.forceVoice;
+                forceVoice =
+                    forceVoice || (args.urgency === "critical" && enforcement.forceVoice);
                 scheduledFor = addMinutes(new Date(previousAttempt.attemptedAt ?? previousAttempt.scheduledFor), enforcement.delayMinutes).toISOString();
             }
             if (Date.parse(scheduledFor) > nowMs) {
@@ -1834,37 +2083,94 @@ export function withReminders(Base) {
                 const responseReview = await this.reviewOwnerResponseAfterReminderAttempt({
                     subjectType: args.subjectType,
                     attempt: previousAttempt,
+                    competingAttempts: ownerAttempts,
                     now: args.now,
                 });
-                if (responseReview.decision === "explicit_resolution" &&
-                    responseReview.resolution !== null) {
+                const reviewTransition = decideReminderReviewTransition({
+                    reviewDue,
+                    ownerType: args.ownerType,
+                    responseReview,
+                });
+                if (reviewTransition.kind === "resolve") {
                     await this.resolveReminderReviewFromOwnerResponse({
                         ownerType: args.ownerType,
                         ownerId: args.ownerId,
                         attempt: previousAttempt,
                         reviewedAt: args.attemptedAt,
-                        resolution: responseReview.resolution,
-                        responseText: responseReview.responseText,
-                        respondedAt: responseReview.respondedAt,
-                        confidence: responseReview.confidence,
-                        reason: responseReview.reason,
+                        resolution: reviewTransition.resolution,
+                        responseText: reviewTransition.responseText,
+                        respondedAt: reviewTransition.respondedAt,
+                        snoozeRequest: reviewTransition.snoozeRequest,
+                        confidence: reviewTransition.confidence,
+                        reason: reviewTransition.reason,
                     });
                     return null;
                 }
-                if (reviewDue) {
+                if (reviewTransition.kind === "clarify") {
                     await this.markReminderReviewObservedResponse({
                         attempt: previousAttempt,
-                        decision: responseReview.decision,
-                        respondedAt: responseReview.respondedAt,
-                        responseText: responseReview.responseText,
-                        reason: responseReview.reason,
+                        decision: reviewTransition.observation.decision,
+                        respondedAt: reviewTransition.observation.respondedAt,
+                        responseText: reviewTransition.observation.responseText,
+                        reason: reviewTransition.observation.reason,
+                    });
+                    const clarificationAttempt = await this.dispatchReminderAttempt({
+                        plan: args.plan,
+                        ownerType: args.ownerType,
+                        ownerId: args.ownerId,
+                        occurrenceId: args.occurrenceId,
+                        subjectType: args.subjectType,
+                        title: args.title,
+                        channel: previousAttempt.channel,
+                        stepIndex: args.plan.steps.length + escalationAttempts.length,
+                        scheduledFor,
+                        dueAt: args.dueAt,
+                        urgency: args.urgency,
+                        quietHours: args.quietHours,
+                        acknowledged: false,
+                        attemptedAt: args.attemptedAt,
+                        lifecycle: "escalation",
+                        escalationIndex: escalationAttempts.length,
+                        escalationReason: "snooze_needs_clarification",
+                        activityProfile: args.activityProfile,
+                        nearbyReminderTitles: args.nearbyReminderTitles,
+                        timezone: args.timezone,
+                        definition: args.definition,
+                        bodyOverride: buildReminderSnoozeClarificationBody(args.title),
+                    });
+                    if (isDeliveredReminderOutcome(clarificationAttempt.outcome)) {
+                        await this.markReminderReviewClarificationRequested({
+                            attempt: previousAttempt,
+                            clarificationAttempt,
+                            requestedAt: args.attemptedAt,
+                        });
+                    }
+                    return clarificationAttempt;
+                }
+                if (reviewTransition.kind === "escalate" &&
+                    reviewTransition.observation) {
+                    await this.markReminderReviewObservedResponse({
+                        attempt: previousAttempt,
+                        decision: reviewTransition.observation.decision,
+                        respondedAt: reviewTransition.observation.respondedAt,
+                        responseText: reviewTransition.observation.responseText,
+                        reason: reviewTransition.observation.reason,
                     });
                 }
             }
+            if (shouldDeferReminderUntilComputerActive({
+                channel: "in_app",
+                definition: args.definition,
+                activityProfile: args.activityProfile,
+                urgency: args.urgency,
+            })) {
+                return null;
+            }
             const candidateChannels = await this.resolveReminderEscalationChannels({
                 activityProfile: args.activityProfile,
                 policies: args.policies,
                 urgency: args.urgency,
+                attempts: ownerAttempts,
             });
             const attemptedChannels = new Set(ownerAttempts.map((attempt) => attempt.channel));
             const lastEscalationAttempt = escalationAttempts.at(-1) ?? null;
@@ -1881,7 +2187,9 @@ export function withReminders(Base) {
                 candidateChannels.includes(previousAttempt.channel)) {
                 nextChannel = previousAttempt.channel;
             }
-            if (forceVoice && nextChannel !== "voice") {
+            if (forceVoice &&
+                nextChannel !== "voice" &&
+                candidateChannels.includes("voice")) {
                 nextChannel = "voice";
             }
             if (!nextChannel) {
@@ -1916,11 +2224,22 @@ export function withReminders(Base) {
             });
             if (readReminderReviewAt(previousAttempt) !== null &&
                 !isReminderReviewClosed(previousAttempt)) {
-                await this.markReminderReviewEscalated({
-                    attempt: previousAttempt,
-                    escalatedAttempt: attempt,
-                    escalatedAt: args.attemptedAt,
-                });
+                if (isDeliveredReminderOutcome(attempt.outcome)) {
+                    await this.markReminderReviewEscalated({
+                        attempt: previousAttempt,
+                        escalatedAttempt: attempt,
+                        escalatedAt: args.attemptedAt,
+                    });
+                }
+                else {
+                    await this.markReminderReviewObservedResponse({
+                        attempt: previousAttempt,
+                        decision: "no_response",
+                        respondedAt: null,
+                        responseText: null,
+                        reason: `review_escalation_attempt_${attempt.outcome}`,
+                    });
+                }
             }
             await this.markReminderEscalationStarted({
                 ownerType: args.ownerType,
@@ -2063,16 +2382,17 @@ export function withReminders(Base) {
             const attemptedAt = args.attemptedAt;
             const attemptedAtDate = new Date(attemptedAt);
             const lifecycle = args.lifecycle ?? "plan";
-            const reminderBody = await this.renderReminderBody({
-                title: args.title,
-                scheduledFor: args.scheduledFor,
-                dueAt: args.dueAt,
-                channel: args.channel,
-                lifecycle,
-                urgency: args.urgency,
-                subjectType: args.subjectType,
-                nearbyReminderTitles: args.nearbyReminderTitles,
-            });
+            const reminderBody = args.bodyOverride ??
+                (await this.renderReminderBody({
+                    title: args.title,
+                    scheduledFor: args.scheduledFor,
+                    dueAt: args.dueAt,
+                    channel: args.channel,
+                    lifecycle,
+                    urgency: args.urgency,
+                    subjectType: args.subjectType,
+                    nearbyReminderTitles: args.nearbyReminderTitles,
+                }));
             let outcome = "delivered";
             let connectorRef = null;
             const deliveryMetadata = {
@@ -2211,6 +2531,11 @@ export function withReminders(Base) {
                             runtimeTarget.target.roomId ??
                             runtimeTarget.target.entityId ??
                             null;
+                    deliveryMetadata.deliveryRoomId = runtimeTarget.target.roomId ?? null;
+                    deliveryMetadata.deliveryChannelId =
+                        runtimeTarget.target.channelId ?? null;
+                    deliveryMetadata.deliveryEntityId =
+                        runtimeTarget.target.entityId ?? null;
                     const sendPayload = {
                         text: reminderBody,
                         source: runtimeTarget.source,
@@ -2254,9 +2579,7 @@ export function withReminders(Base) {
             }
             if (outcome === "delivered" &&
                 (args.urgency === "high" || args.urgency === "critical")) {
-                const reviewDelayMinutes = lifecycle === "escalation"
-                    ? REMINDER_ESCALATION_DELAYS[args.urgency].repeatMinutes
-                    : REMINDER_ESCALATION_DELAYS[args.urgency].initialMinutes;
+                const reviewDelayMinutes = resolveReminderReviewDelayMinutes(args.urgency, lifecycle);
                 if (reviewDelayMinutes !== null) {
                     deliveryMetadata[REMINDER_REVIEW_AFTER_MINUTES_METADATA_KEY] =
                         reviewDelayMinutes;
@@ -2596,6 +2919,274 @@ export function withReminders(Base) {
                 policies: [smsPolicy, voicePolicy],
             };
         }
+        async processDueReminderDeliveries(args) {
+            const { now, limit, ownerTimezone, policies, globalReminderPreference, existingAttempts, activityProfile, } = args;
+            const dueAttempts = [];
+            if (limit <= 0) {
+                return dueAttempts;
+            }
+            const definitions = await this.repository.listActiveDefinitions(this.agentId());
+            for (const definition of definitions) {
+                await this.refreshDefinitionOccurrences(definition, now);
+            }
+            const definitionsById = new Map(definitions.map((definition) => [definition.id, definition]));
+            const horizon = addMinutes(now, OVERVIEW_HORIZON_MINUTES).toISOString();
+            const occurrenceViews = await this.repository.listOccurrenceViewsForOverview(this.agentId(), horizon);
+            const occurrencePlans = await this.repository.listReminderPlansForOwners(this.agentId(), "definition", occurrenceViews.map((occurrence) => occurrence.definitionId));
+            const definitionPreferencesById = new Map();
+            const plansByDefinitionId = new Map();
+            for (const plan of occurrencePlans) {
+                const definition = definitionsById.get(plan.ownerId) ?? null;
+                const preference = this.buildReminderPreferenceResponse(definition, policies);
+                definitionPreferencesById.set(plan.ownerId, preference);
+                const effectivePlan = this.resolveEffectiveReminderPlan(plan, preference);
+                if (effectivePlan) {
+                    plansByDefinitionId.set(plan.ownerId, effectivePlan);
+                }
+            }
+            const eventWindowEnd = addMinutes(now, OVERVIEW_HORIZON_MINUTES).toISOString();
+            const calendarEvents = await this.repository.listCalendarEvents(this.agentId(), "google", now.toISOString(), eventWindowEnd);
+            const eventPlans = await this.repository.listReminderPlansForOwners(this.agentId(), "calendar_event", calendarEvents.map((event) => event.id));
+            const occurrenceUrgencies = new Map();
+            for (const occurrence of occurrenceViews) {
+                occurrenceUrgencies.set(occurrence.id, resolveReminderDeliveryUrgency({
+                    metadata: occurrence.metadata,
+                    priority: occurrence.priority,
+                }));
+            }
+            const plansByEventId = new Map();
+            for (const plan of eventPlans) {
+                const effectivePlan = this.resolveEffectiveReminderPlan(plan, globalReminderPreference);
+                if (effectivePlan) {
+                    plansByEventId.set(plan.ownerId, effectivePlan);
+                }
+            }
+            const eventUrgencies = new Map();
+            for (const event of calendarEvents) {
+                eventUrgencies.set(event.id, resolveReminderDeliveryUrgency({
+                    metadata: event.metadata,
+                    fallback: "medium",
+                }));
+            }
+            const attemptKey = (planId, stepIndex, scheduledFor) => `${planId}:${stepIndex}:${scheduledFor}`;
+            const deliveredAttempts = new Set(existingAttempts
+                .filter((attempt) => isDeliveredReminderOutcome(attempt.outcome))
+                .map((attempt) => attemptKey(attempt.planId, attempt.stepIndex, attempt.scheduledFor)));
+            const blockedAckAttempts = new Set(existingAttempts
+                .filter((attempt) => attempt.outcome === "blocked_acknowledged")
+                .map((attempt) => attemptKey(attempt.planId, attempt.stepIndex, attempt.scheduledFor)));
+            for (const reminder of buildActiveReminders(occurrenceViews, plansByDefinitionId, now)) {
+                if (dueAttempts.length >= limit)
+                    break;
+                const plan = reminder.definitionId
+                    ? plansByDefinitionId.get(reminder.definitionId)
+                    : null;
+                if (!plan)
+                    continue;
+                const occurrence = occurrenceViews.find((candidate) => candidate.id === reminder.ownerId);
+                if (!occurrence)
+                    continue;
+                const preference = definitionPreferencesById.get(reminder.definitionId ?? "") ??
+                    globalReminderPreference;
+                const urgency = occurrenceUrgencies.get(reminder.ownerId) ?? "medium";
+                const definition = definitionsById.get(occurrence.definitionId) ?? null;
+                if (!shouldDeliverReminderForIntensity(preference.effective.intensity, urgency)) {
+                    continue;
+                }
+                const key = attemptKey(plan.id, reminder.stepIndex, reminder.scheduledFor);
+                const acknowledged = Boolean(occurrence.metadata.reminderAcknowledgedAt ||
+                    occurrence.state === "completed");
+                if (deliveredAttempts.has(key) ||
+                    (acknowledged && blockedAckAttempts.has(key))) {
+                    continue;
+                }
+                if (shouldDeferReminderUntilComputerActive({
+                    channel: reminder.channel,
+                    definition,
+                    activityProfile,
+                    urgency,
+                })) {
+                    continue;
+                }
+                const attempt = await this.dispatchReminderAttempt({
+                    plan,
+                    ownerType: "occurrence",
+                    ownerId: reminder.ownerId,
+                    occurrenceId: reminder.occurrenceId,
+                    subjectType: occurrence.subjectType,
+                    title: reminder.title,
+                    channel: reminder.channel,
+                    stepIndex: reminder.stepIndex,
+                    scheduledFor: reminder.scheduledFor,
+                    dueAt: occurrence.dueAt,
+                    urgency,
+                    quietHours: plan.quietHours,
+                    acknowledged,
+                    attemptedAt: now.toISOString(),
+                    activityProfile,
+                    nearbyReminderTitles: collectNearbyReminderTitles({
+                        currentOwnerId: reminder.ownerId,
+                        currentAnchorAt: occurrence.dueAt,
+                        occurrences: occurrenceViews,
+                        events: calendarEvents,
+                        limit: 3,
+                    }),
+                    timezone: ownerTimezone,
+                    definition,
+                });
+                dueAttempts.push(attempt);
+                if (isDeliveredReminderOutcome(attempt.outcome)) {
+                    deliveredAttempts.add(key);
+                }
+            }
+            for (const reminder of buildActiveCalendarEventReminders(calendarEvents, plansByEventId, this.ownerEntityId(), now)) {
+                if (dueAttempts.length >= limit)
+                    break;
+                const plan = reminder.eventId
+                    ? plansByEventId.get(reminder.eventId)
+                    : null;
+                if (!plan)
+                    continue;
+                const event = calendarEvents.find((candidate) => candidate.id === reminder.ownerId);
+                if (!event)
+                    continue;
+                if (!shouldDeliverReminderForIntensity(globalReminderPreference.effective.intensity, eventUrgencies.get(reminder.ownerId) ?? "medium")) {
+                    continue;
+                }
+                const key = attemptKey(plan.id, reminder.stepIndex, reminder.scheduledFor);
+                const acknowledged = Boolean(event.metadata.reminderAcknowledgedAt);
+                if (deliveredAttempts.has(key) ||
+                    (acknowledged && blockedAckAttempts.has(key))) {
+                    continue;
+                }
+                const attempt = await this.dispatchReminderAttempt({
+                    plan,
+                    ownerType: "calendar_event",
+                    ownerId: reminder.ownerId,
+                    occurrenceId: null,
+                    subjectType: reminder.subjectType,
+                    title: reminder.title,
+                    channel: reminder.channel,
+                    stepIndex: reminder.stepIndex,
+                    scheduledFor: reminder.scheduledFor,
+                    dueAt: reminder.dueAt,
+                    urgency: resolveReminderDeliveryUrgency({
+                        metadata: event.metadata,
+                        fallback: "medium",
+                    }),
+                    quietHours: plan.quietHours,
+                    acknowledged,
+                    attemptedAt: now.toISOString(),
+                    activityProfile,
+                    nearbyReminderTitles: collectNearbyReminderTitles({
+                        currentOwnerId: reminder.ownerId,
+                        currentAnchorAt: reminder.dueAt,
+                        occurrences: occurrenceViews,
+                        events: calendarEvents,
+                        limit: 3,
+                    }),
+                    timezone: ownerTimezone,
+                    definition: null,
+                });
+                dueAttempts.push(attempt);
+                if (isDeliveredReminderOutcome(attempt.outcome)) {
+                    deliveredAttempts.add(key);
+                }
+            }
+            const reminderAttemptsForEscalation = [
+                ...existingAttempts,
+                ...dueAttempts,
+            ];
+            await this.scanReadReceipts(reminderAttemptsForEscalation, activityProfile, now);
+            for (const occurrence of occurrenceViews) {
+                if (dueAttempts.length >= limit)
+                    break;
+                const plan = plansByDefinitionId.get(occurrence.definitionId) ?? null;
+                if (!plan)
+                    continue;
+                const acknowledged = Boolean(occurrence.metadata.reminderAcknowledgedAt ||
+                    occurrence.state === "completed");
+                const attempt = await this.dispatchDueReminderEscalation({
+                    plan,
+                    ownerType: "occurrence",
+                    ownerId: occurrence.id,
+                    occurrenceId: occurrence.id,
+                    subjectType: occurrence.subjectType,
+                    title: occurrence.title,
+                    dueAt: occurrence.dueAt,
+                    urgency: resolveReminderDeliveryUrgency({
+                        metadata: occurrence.metadata,
+                        priority: occurrence.priority,
+                    }),
+                    intensity: definitionPreferencesById.get(occurrence.definitionId)?.effective
+                        ?.intensity ?? globalReminderPreference.effective.intensity,
+                    quietHours: plan.quietHours,
+                    attemptedAt: now.toISOString(),
+                    now,
+                    attempts: reminderAttemptsForEscalation,
+                    policies,
+                    activityProfile,
+                    occurrence,
+                    acknowledged,
+                    nearbyReminderTitles: collectNearbyReminderTitles({
+                        currentOwnerId: occurrence.id,
+                        currentAnchorAt: occurrence.dueAt,
+                        occurrences: occurrenceViews,
+                        events: calendarEvents,
+                        limit: 3,
+                    }),
+                    timezone: ownerTimezone,
+                    definition: definitionsById.get(occurrence.definitionId) ?? null,
+                });
+                if (!attempt)
+                    continue;
+                dueAttempts.push(attempt);
+                reminderAttemptsForEscalation.push(attempt);
+            }
+            for (const event of calendarEvents) {
+                if (dueAttempts.length >= limit)
+                    break;
+                const plan = plansByEventId.get(event.id) ?? null;
+                if (!plan)
+                    continue;
+                const attempt = await this.dispatchDueReminderEscalation({
+                    plan,
+                    ownerType: "calendar_event",
+                    ownerId: event.id,
+                    occurrenceId: null,
+                    subjectType: "owner",
+                    title: event.title,
+                    dueAt: event.startAt,
+                    urgency: resolveReminderDeliveryUrgency({
+                        metadata: event.metadata,
+                        fallback: "medium",
+                    }),
+                    intensity: globalReminderPreference.effective.intensity,
+                    quietHours: plan.quietHours,
+                    attemptedAt: now.toISOString(),
+                    now,
+                    attempts: reminderAttemptsForEscalation,
+                    policies,
+                    activityProfile,
+                    eventStartAt: event.startAt,
+                    acknowledged: Boolean(event.metadata.reminderAcknowledgedAt),
+                    nearbyReminderTitles: collectNearbyReminderTitles({
+                        currentOwnerId: event.id,
+                        currentAnchorAt: event.startAt,
+                        occurrences: occurrenceViews,
+                        events: calendarEvents,
+                        limit: 3,
+                    }),
+                    timezone: ownerTimezone,
+                    definition: null,
+                });
+                if (!attempt)
+                    continue;
+                dueAttempts.push(attempt);
+                reminderAttemptsForEscalation.push(attempt);
+            }
+            return dueAttempts;
+        }
         async processReminders(request = {}) {
             return this.withReminderProcessingLock(async () => {
                 const now = request.now === undefined
@@ -2605,275 +3196,35 @@ export function withReminders(Base) {
                     ? DEFAULT_REMINDER_PROCESS_LIMIT
                     : normalizePositiveInteger(request.limit, "limit");
                 const ownerTimezone = resolveDefaultTimeZone();
-                const definitions = await this.repository.listActiveDefinitions(this.agentId());
-                for (const definition of definitions) {
-                    await this.refreshDefinitionOccurrences(definition, now);
-                }
-                const definitionsById = new Map(definitions.map((definition) => [definition.id, definition]));
-                const horizon = addMinutes(now, OVERVIEW_HORIZON_MINUTES).toISOString();
-                const occurrenceViews = await this.repository.listOccurrenceViewsForOverview(this.agentId(), horizon);
-                const occurrencePlans = await this.repository.listReminderPlansForOwners(this.agentId(), "definition", occurrenceViews.map((occurrence) => occurrence.definitionId));
                 const policies = await this.repository.listChannelPolicies(this.agentId());
-                const definitionPreferencesById = new Map();
-                const plansByDefinitionId = new Map();
-                for (const plan of occurrencePlans) {
-                    const definition = definitionsById.get(plan.ownerId) ?? null;
-                    const preference = this.buildReminderPreferenceResponse(definition, policies);
-                    definitionPreferencesById.set(plan.ownerId, preference);
-                    const effectivePlan = this.resolveEffectiveReminderPlan(plan, preference);
-                    if (effectivePlan) {
-                        plansByDefinitionId.set(plan.ownerId, effectivePlan);
-                    }
-                }
-                const eventWindowEnd = addMinutes(now, OVERVIEW_HORIZON_MINUTES).toISOString();
-                const calendarEvents = await this.repository.listCalendarEvents(this.agentId(), "google", now.toISOString(), eventWindowEnd);
-                const eventPlans = await this.repository.listReminderPlansForOwners(this.agentId(), "calendar_event", calendarEvents.map((event) => event.id));
                 const globalReminderPreference = this.buildReminderPreferenceResponse(null, policies);
-                const occurrenceUrgencies = new Map();
-                for (const occurrence of occurrenceViews) {
-                    occurrenceUrgencies.set(occurrence.id, resolveReminderDeliveryUrgency({
-                        metadata: occurrence.metadata,
-                        priority: occurrence.priority,
-                    }));
-                }
-                const plansByEventId = new Map();
-                for (const plan of eventPlans) {
-                    const effectivePlan = this.resolveEffectiveReminderPlan(plan, globalReminderPreference);
-                    if (effectivePlan) {
-                        plansByEventId.set(plan.ownerId, effectivePlan);
-                    }
-                }
-                const eventUrgencies = new Map();
-                for (const event of calendarEvents) {
-                    eventUrgencies.set(event.id, resolveReminderDeliveryUrgency({
-                        metadata: event.metadata,
-                        fallback: "medium",
-                    }));
-                }
                 const existingAttempts = await this.repository.listReminderAttempts(this.agentId());
-                const attemptKey = (planId, stepIndex, scheduledFor) => `${planId}:${stepIndex}:${scheduledFor}`;
-                const deliveredAttempts = new Set(existingAttempts
-                    .filter((attempt) => attempt.outcome === "delivered" ||
-                    attempt.outcome === "delivered_read" ||
-                    attempt.outcome === "delivered_unread")
-                    .map((attempt) => attemptKey(attempt.planId, attempt.stepIndex, attempt.scheduledFor)));
-                const blockedAckAttempts = new Set(existingAttempts
-                    .filter((attempt) => attempt.outcome === "blocked_acknowledged")
-                    .map((attempt) => attemptKey(attempt.planId, attempt.stepIndex, attempt.scheduledFor)));
                 const activityProfile = await this.readReminderActivityProfileSnapshot();
                 const dueAttempts = [];
-                for (const reminder of buildActiveReminders(occurrenceViews, plansByDefinitionId, now)) {
-                    if (dueAttempts.length >= limit)
-                        break;
-                    const plan = reminder.definitionId
-                        ? plansByDefinitionId.get(reminder.definitionId)
-                        : null;
-                    if (!plan)
-                        continue;
-                    const occurrence = occurrenceViews.find((candidate) => candidate.id === reminder.ownerId);
-                    if (!occurrence)
-                        continue;
-                    const preference = definitionPreferencesById.get(reminder.definitionId ?? "") ??
-                        globalReminderPreference;
-                    const urgency = occurrenceUrgencies.get(reminder.ownerId) ?? "medium";
-                    const definition = definitionsById.get(occurrence.definitionId) ?? null;
-                    if (!shouldDeliverReminderForIntensity(preference.effective.intensity, urgency)) {
-                        continue;
-                    }
-                    const key = attemptKey(plan.id, reminder.stepIndex, reminder.scheduledFor);
-                    const acknowledged = Boolean(occurrence.metadata.reminderAcknowledgedAt ||
-                        occurrence.state === "completed");
-                    if (deliveredAttempts.has(key) ||
-                        (acknowledged && blockedAckAttempts.has(key))) {
-                        continue;
-                    }
-                    if (shouldDeferReminderUntilComputerActive({
-                        channel: reminder.channel,
-                        definition,
-                        activityProfile,
-                        urgency,
-                    })) {
-                        continue;
-                    }
-                    const attempt = await this.dispatchReminderAttempt({
-                        plan,
-                        ownerType: "occurrence",
-                        ownerId: reminder.ownerId,
-                        occurrenceId: reminder.occurrenceId,
-                        subjectType: occurrence.subjectType,
-                        title: reminder.title,
-                        channel: reminder.channel,
-                        stepIndex: reminder.stepIndex,
-                        scheduledFor: reminder.scheduledFor,
-                        dueAt: occurrence.dueAt,
-                        urgency,
-                        quietHours: plan.quietHours,
-                        acknowledged,
-                        attemptedAt: now.toISOString(),
-                        activityProfile,
-                        nearbyReminderTitles: collectNearbyReminderTitles({
-                            currentOwnerId: reminder.ownerId,
-                            currentAnchorAt: occurrence.dueAt,
-                            occurrences: occurrenceViews,
-                            events: calendarEvents,
-                            limit: 3,
-                        }),
-                        timezone: ownerTimezone,
-                        definition,
-                    });
-                    dueAttempts.push(attempt);
-                    if (attempt.outcome === "delivered") {
-                        deliveredAttempts.add(key);
-                    }
-                }
-                for (const reminder of buildActiveCalendarEventReminders(calendarEvents, plansByEventId, this.ownerEntityId(), now)) {
-                    if (dueAttempts.length >= limit)
-                        break;
-                    const plan = reminder.eventId
-                        ? plansByEventId.get(reminder.eventId)
-                        : null;
-                    if (!plan)
-                        continue;
-                    const event = calendarEvents.find((candidate) => candidate.id === reminder.ownerId);
-                    if (!event)
-                        continue;
-                    if (!shouldDeliverReminderForIntensity(globalReminderPreference.effective.intensity, eventUrgencies.get(reminder.ownerId) ?? "medium")) {
-                        continue;
-                    }
-                    const key = attemptKey(plan.id, reminder.stepIndex, reminder.scheduledFor);
-                    const acknowledged = Boolean(event.metadata.reminderAcknowledgedAt);
-                    if (deliveredAttempts.has(key) ||
-                        (acknowledged && blockedAckAttempts.has(key))) {
-                        continue;
-                    }
-                    const attempt = await this.dispatchReminderAttempt({
-                        plan,
-                        ownerType: "calendar_event",
-                        ownerId: reminder.ownerId,
-                        occurrenceId: null,
-                        subjectType: reminder.subjectType,
-                        title: reminder.title,
-                        channel: reminder.channel,
-                        stepIndex: reminder.stepIndex,
-                        scheduledFor: reminder.scheduledFor,
-                        dueAt: reminder.dueAt,
-                        urgency: resolveReminderDeliveryUrgency({
-                            metadata: event.metadata,
-                            fallback: "medium",
-                        }),
-                        quietHours: plan.quietHours,
-                        acknowledged,
-                        attemptedAt: now.toISOString(),
-                        activityProfile,
-                        nearbyReminderTitles: collectNearbyReminderTitles({
-                            currentOwnerId: reminder.ownerId,
-                            currentAnchorAt: reminder.dueAt,
-                            occurrences: occurrenceViews,
-                            events: calendarEvents,
-                            limit: 3,
-                        }),
-                        timezone: ownerTimezone,
-                        definition: null,
-                    });
-                    dueAttempts.push(attempt);
-                    if (attempt.outcome === "delivered") {
-                        deliveredAttempts.add(key);
-                    }
-                }
-                const reminderAttemptsForEscalation = [
-                    ...existingAttempts,
-                    ...dueAttempts,
-                ];
-                // Scan recent "delivered" attempts and upgrade to "delivered_read" when
-                // the owner was active after delivery. This improves escalation decisions.
-                await this.scanReadReceipts(reminderAttemptsForEscalation, activityProfile, now);
-                for (const occurrence of occurrenceViews) {
-                    if (dueAttempts.length >= limit)
-                        break;
-                    const plan = plansByDefinitionId.get(occurrence.definitionId) ?? null;
-                    if (!plan)
-                        continue;
-                    const acknowledged = Boolean(occurrence.metadata.reminderAcknowledgedAt ||
-                        occurrence.state === "completed");
-                    const attempt = await this.dispatchDueReminderEscalation({
-                        plan,
-                        ownerType: "occurrence",
-                        ownerId: occurrence.id,
-                        occurrenceId: occurrence.id,
-                        subjectType: occurrence.subjectType,
-                        title: occurrence.title,
-                        dueAt: occurrence.dueAt,
-                        urgency: resolveReminderDeliveryUrgency({
-                            metadata: occurrence.metadata,
-                            priority: occurrence.priority,
-                        }),
-                        intensity: definitionPreferencesById.get(occurrence.definitionId)?.effective
-                            ?.intensity ?? globalReminderPreference.effective.intensity,
-                        quietHours: plan.quietHours,
-                        attemptedAt: now.toISOString(),
-                        now,
-                        attempts: reminderAttemptsForEscalation,
-                        policies,
-                        activityProfile,
-                        occurrence,
-                        acknowledged,
-                        nearbyReminderTitles: collectNearbyReminderTitles({
-                            currentOwnerId: occurrence.id,
-                            currentAnchorAt: occurrence.dueAt,
-                            occurrences: occurrenceViews,
-                            events: calendarEvents,
-                            limit: 3,
-                        }),
-                        timezone: ownerTimezone,
-                        definition: definitionsById.get(occurrence.definitionId) ?? null,
-                    });
-                    if (!attempt)
-                        continue;
-                    dueAttempts.push(attempt);
-                    reminderAttemptsForEscalation.push(attempt);
-                }
-                for (const event of calendarEvents) {
-                    if (dueAttempts.length >= limit)
-                        break;
-                    const plan = plansByEventId.get(event.id) ?? null;
-                    if (!plan)
-                        continue;
-                    const attempt = await this.dispatchDueReminderEscalation({
-                        plan,
-                        ownerType: "calendar_event",
-                        ownerId: event.id,
-                        occurrenceId: null,
-                        subjectType: "owner",
-                        title: event.title,
-                        dueAt: event.startAt,
-                        urgency: resolveReminderDeliveryUrgency({
-                            metadata: event.metadata,
-                            fallback: "medium",
-                        }),
-                        intensity: globalReminderPreference.effective.intensity,
-                        quietHours: plan.quietHours,
-                        attemptedAt: now.toISOString(),
-                        now,
-                        attempts: reminderAttemptsForEscalation,
-                        policies,
-                        activityProfile,
-                        eventStartAt: event.startAt,
-                        acknowledged: Boolean(event.metadata.reminderAcknowledgedAt),
-                        nearbyReminderTitles: collectNearbyReminderTitles({
-                            currentOwnerId: event.id,
-                            currentAnchorAt: event.startAt,
-                            occurrences: occurrenceViews,
-                            events: calendarEvents,
-                            limit: 3,
-                        }),
-                        timezone: ownerTimezone,
-                        definition: null,
-                    });
-                    if (!attempt)
-                        continue;
-                    dueAttempts.push(attempt);
-                    reminderAttemptsForEscalation.push(attempt);
+                dueAttempts.push(...(await this.processDueReminderReviewJobs({
+                    now,
+                    limit,
+                    attempts: existingAttempts,
+                    policies,
+                    activityProfile,
+                    timezone: ownerTimezone,
+                    defaultIntensity: globalReminderPreference.effective.intensity,
+                })));
+                if (dueAttempts.length >= limit) {
+                    return {
+                        now: now.toISOString(),
+                        attempts: dueAttempts,
+                    };
                 }
+                dueAttempts.push(...(await this.processDueReminderDeliveries({
+                    now,
+                    limit: limit - dueAttempts.length,
+                    ownerTimezone,
+                    policies,
+                    globalReminderPreference,
+                    existingAttempts: [...existingAttempts, ...dueAttempts],
+                    activityProfile,
+                })));
                 return {
                     now: now.toISOString(),
                     attempts: dueAttempts,