@elizaos/agent 2.0.0-alpha.441 → 2.0.0-alpha.501

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

@@ -17,8 +17,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 { computeDefinitionPerformance } from "./service-helpers-occurrence.js";
-import { shouldDeferReminderUntilComputerActive } from "./service-helpers-reminder.js";
+import { classifyReminderOwnerResponseText, rankReminderEscalationChannels, readReminderAttemptLifecycle, resolveReminderDeliveryUrgency, resolveReminderEscalationDelayMinutes, shouldDeferReminderUntilComputerActive, shouldDeliverReminderForIntensity, shouldEscalateImmediately, } 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";
@@ -224,27 +226,6 @@ const LIFEOPS_OWNER_CONTACTS_LOAD_CONTEXT = {
     envPrefix: "LIFEOPS_OWNER_",
 };
 // Reminder-specific helpers
-function normalizeReminderUrgency(value) {
-    if (typeof value !== "string")
-        return "medium";
-    const lower = value.toLowerCase().trim();
-    if (lower === "low" ||
-        lower === "medium" ||
-        lower === "high" ||
-        lower === "critical") {
-        return lower;
-    }
-    return "medium";
-}
-function priorityToUrgency(priority) {
-    if (priority >= 80)
-        return "critical";
-    if (priority >= 50)
-        return "high";
-    if (priority >= 20)
-        return "medium";
-    return "low";
-}
 const REMINDER_INTENSITY_CANONICAL_ALIASES = {
     minimal: "minimal",
     normal: "normal",
@@ -270,66 +251,49 @@ function isReminderChannel(value) {
             value === "email" ||
             value === "telegram" ||
             value === "discord" ||
+            value === "signal" ||
+            value === "whatsapp" ||
+            value === "imessage" ||
             value === "sms" ||
-            value === "voice"));
+            value === "voice" ||
+            value === "push"));
 }
-function isReminderChannelAllowedForUrgency(channel, urgency) {
-    if (channel === "voice" && urgency !== "critical" && urgency !== "high") {
-        return false;
-    }
-    return true;
+function isDeliveredReminderOutcome(outcome) {
+    return (outcome === "delivered" ||
+        outcome === "delivered_read" ||
+        outcome === "delivered_unread");
 }
-function shouldDeliverReminderForIntensity(intensity, urgency) {
-    if (intensity === "high_priority_only") {
-        return urgency === "critical" || urgency === "high";
-    }
-    if (intensity === "minimal") {
-        return urgency === "critical";
+function readReminderReviewAt(attempt) {
+    const value = attempt.deliveryMetadata?.[REMINDER_REVIEW_AT_METADATA_KEY];
+    if (typeof value !== "string") {
+        return null;
     }
-    return true;
+    return Number.isFinite(Date.parse(value)) ? value : null;
 }
-function mapPlatformToReminderChannel(platform) {
-    if (!platform)
-        return null;
-    const lower = platform.toLowerCase();
-    if (lower === "telegram")
-        return "telegram";
-    if (lower === "discord")
-        return "discord";
-    if (lower === "email")
-        return "email";
-    if (lower === "sms")
-        return "sms";
-    if (lower === "voice")
-        return "voice";
-    if (lower === "in_app" || lower === "app" || lower === "client_chat")
-        return "in_app";
-    return 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 readReminderAttemptLifecycle(attempt) {
-    const metadata = attempt.deliveryMetadata ?? {};
-    return metadata[REMINDER_LIFECYCLE_METADATA_KEY] === "escalation"
-        ? "escalation"
-        : "plan";
+function isReminderReviewClosed(attempt) {
+    const status = readReminderReviewStatus(attempt);
+    return status === "resolved" || status === "escalated";
 }
-function shouldEscalateImmediately(outcome) {
-    return (outcome === "blocked_connector" ||
-        outcome === "blocked_policy" ||
-        outcome === "blocked_quiet_hours");
+function readReminderAttemptAnchorMs(attempt) {
+    const attempted = attempt.attemptedAt ? Date.parse(attempt.attemptedAt) : NaN;
+    if (Number.isFinite(attempted)) {
+        return attempted;
+    }
+    const scheduled = Date.parse(attempt.scheduledFor);
+    return Number.isFinite(scheduled) ? scheduled : Number.NEGATIVE_INFINITY;
 }
-const REMINDER_ESCALATION_DELAYS = {
-    low: { initialMinutes: null, repeatMinutes: null },
-    medium: { initialMinutes: 90, repeatMinutes: 180 },
-    high: { initialMinutes: 20, repeatMinutes: 45 },
-    critical: { initialMinutes: 5, repeatMinutes: 15 },
-};
-function resolveReminderEscalationDelayMinutes(urgency, previousOutcome, hasEscalated) {
-    const delays = REMINDER_ESCALATION_DELAYS[urgency];
-    if (!delays.initialMinutes)
-        return null;
-    if (shouldEscalateImmediately(previousOutcome))
-        return 0;
-    return hasEscalated ? delays.repeatMinutes : delays.initialMinutes;
+function readLatestPendingReminderReviewAttempt(attempts) {
+    return (attempts
+        .filter((attempt) => isDeliveredReminderOutcome(attempt.outcome) &&
+        readReminderReviewAt(attempt) !== null &&
+        !isReminderReviewClosed(attempt))
+        .sort((left, right) => readReminderAttemptAnchorMs(left) -
+        readReminderAttemptAnchorMs(right))
+        .at(-1) ?? null);
 }
 function readReminderPreferenceSettingFromMetadata(metadata, source) {
     if (!metadata)
@@ -365,27 +329,6 @@ function applyReminderIntensityToPlan(plan, intensity) {
     }
     return plan;
 }
-function isWithinQuietHours(args) {
-    if (!args.quietHours ||
-        typeof args.quietHours !== "object" ||
-        !("startHour" in args.quietHours) ||
-        !("endHour" in args.quietHours)) {
-        return false;
-    }
-    const startHour = typeof args.quietHours.startHour === "number"
-        ? args.quietHours.startHour
-        : null;
-    const endHour = typeof args.quietHours.endHour === "number"
-        ? args.quietHours.endHour
-        : null;
-    if (startHour === null || endHour === null)
-        return false;
-    const hour = args.now.getHours();
-    if (startHour <= endHour) {
-        return hour >= startHour && hour < endHour;
-    }
-    return hour >= startHour || hour < endHour;
-}
 function buildReminderBody(args) {
     const parts = [];
     if (args.lifecycle === "escalation") {
@@ -430,6 +373,17 @@ function formatReminderConversationLine(args) {
     const prefix = isAgent ? args.agentName : "User";
     return `${prefix}: ${text}`;
 }
+function readMemoryCreatedAtMs(memory) {
+    if (typeof memory.createdAt === "number" &&
+        Number.isFinite(memory.createdAt)) {
+        return memory.createdAt;
+    }
+    if (typeof memory.createdAt === "string") {
+        const parsed = Date.parse(memory.createdAt);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
 function normalizeGeneratedReminderBody(value) {
     const cleaned = value.replace(/^["'`]+|["'`]+$/g, "").trim();
     return cleaned.length > 0 ? cleaned : null;
@@ -633,6 +587,88 @@ export function withReminders(Base) {
                 return [];
             }
         }
+        async reviewOwnerResponseAfterReminderAttempt(args) {
+            const noResponse = {
+                decision: "no_response",
+                resolution: null,
+                respondedAt: null,
+                responseText: null,
+                confidence: 0,
+                reason: "no_owner_response",
+            };
+            if (args.subjectType !== "owner" ||
+                typeof this.runtime.getRoomsForParticipants !== "function" ||
+                typeof this.runtime.getMemoriesByRoomIds !== "function") {
+                return noResponse;
+            }
+            const attemptedAt = args.attempt.attemptedAt ?? args.attempt.scheduledFor ?? null;
+            const attemptedMs = attemptedAt ? Date.parse(attemptedAt) : Number.NaN;
+            if (!Number.isFinite(attemptedMs)) {
+                return noResponse;
+            }
+            const ownerEntityId = (await this.ownerRoutingEntityId()) ?? this.ownerEntityId();
+            const agentId = this.agentId();
+            try {
+                const roomIds = await this.runtime.getRoomsForParticipants([
+                    ownerEntityId,
+                    agentId,
+                ]);
+                if (!Array.isArray(roomIds) || roomIds.length === 0) {
+                    return noResponse;
+                }
+                const memories = await this.runtime.getMemoriesByRoomIds({
+                    tableName: "messages",
+                    roomIds,
+                    limit: 50,
+                });
+                if (!Array.isArray(memories) || memories.length === 0) {
+                    return noResponse;
+                }
+                const nowMs = args.now.getTime();
+                const ownerResponses = memories
+                    .filter((memory) => memory.entityId === ownerEntityId)
+                    .map((memory) => {
+                    const createdAt = readMemoryCreatedAtMs(memory);
+                    const text = typeof memory.content?.text === "string"
+                        ? memory.content.text.trim()
+                        : "";
+                    return { createdAt, text };
+                })
+                    .filter((response) => response.createdAt !== null &&
+                    response.createdAt > attemptedMs &&
+                    response.createdAt <= nowMs &&
+                    response.text.length > 0)
+                    .sort((left, right) => left.createdAt - right.createdAt);
+                if (ownerResponses.length === 0) {
+                    return noResponse;
+                }
+                for (const response of ownerResponses) {
+                    const classification = classifyReminderOwnerResponseText(response.text);
+                    if (classification.decision === "explicit_resolution") {
+                        return {
+                            decision: "explicit_resolution",
+                            resolution: classification.resolution,
+                            respondedAt: new Date(response.createdAt).toISOString(),
+                            responseText: response.text,
+                            confidence: classification.confidence,
+                            reason: classification.reason,
+                        };
+                    }
+                }
+                const latest = ownerResponses.at(-1);
+                return {
+                    decision: "unrelated",
+                    resolution: null,
+                    respondedAt: latest ? new Date(latest.createdAt).toISOString() : null,
+                    responseText: latest?.text ?? null,
+                    confidence: 0.4,
+                    reason: "owner_responded_without_explicit_reminder_resolution",
+                };
+            }
+            catch {
+                return noResponse;
+            }
+        }
         async renderReminderBody(args) {
             const fallback = buildReminderBody({
                 title: args.title,
@@ -686,7 +722,6 @@ export function withReminders(Base) {
                 "Reminder text:",
             ].join("\n");
             try {
-                // biome-ignore lint/correctness/useHookAtTopLevel: runtime.useModel is an elizaOS model API, not a React hook.
                 const response = await this.runtime.useModel(ModelType.TEXT_SMALL, {
                     prompt,
                 });
@@ -739,7 +774,6 @@ export function withReminders(Base) {
                 "Message text:",
             ].join("\n");
             try {
-                // biome-ignore lint/correctness/useHookAtTopLevel: runtime.useModel is an elizaOS model API, not a React hook.
                 const response = await this.runtime.useModel(ModelType.TEXT_SMALL, {
                     prompt,
                 });
@@ -1489,17 +1523,6 @@ export function withReminders(Base) {
             const ordered = [];
             const ownerContacts = loadOwnerContactsConfig(LIFEOPS_OWNER_CONTACTS_LOAD_CONTEXT);
             const ownerContactHints = await loadOwnerContactRoutingHints(this.runtime, ownerContacts);
-            const preferredChannels = new Set();
-            for (const hint of Object.values(ownerContactHints)) {
-                const preferredChannel = mapPlatformToReminderChannel(hint.preferredCommunicationChannel);
-                const recentChannel = mapPlatformToReminderChannel(hint.lastResponseChannel);
-                if (preferredChannel) {
-                    preferredChannels.add(preferredChannel);
-                }
-                if (recentChannel) {
-                    preferredChannels.add(recentChannel);
-                }
-            }
             const pushChannel = async (channel) => {
                 if (!channel || ordered.includes(channel)) {
                     return;
@@ -1532,23 +1555,14 @@ export function withReminders(Base) {
                     ordered.push(channel);
                 }
             };
-            await pushChannel(mapPlatformToReminderChannel(args.activityProfile?.isCurrentlyActive
-                ? args.activityProfile.lastSeenPlatform
-                : null));
-            await pushChannel(mapPlatformToReminderChannel(args.activityProfile?.primaryPlatform));
-            await pushChannel(mapPlatformToReminderChannel(args.activityProfile?.secondaryPlatform));
-            for (const preferredChannel of preferredChannels) {
-                await pushChannel(preferredChannel);
-            }
-            for (const source of Object.keys(ownerContacts)) {
-                const mappedChannel = mapPlatformToReminderChannel(source);
-                if (mappedChannel === "in_app") {
-                    continue;
-                }
-                await pushChannel(mappedChannel);
-            }
-            for (const policy of args.policies) {
-                await pushChannel(isReminderChannel(policy.channelType) ? policy.channelType : null);
+            const rankedChannels = rankReminderEscalationChannels({
+                activityProfile: args.activityProfile,
+                ownerContactHints,
+                ownerContactSources: Object.keys(ownerContacts),
+                policyChannels: args.policies.map((policy) => policy.channelType),
+            });
+            for (const channel of rankedChannels) {
+                await pushChannel(channel);
             }
             return ordered;
         }
@@ -1667,6 +1681,75 @@ export function withReminders(Base) {
                 lastEscalationOutcome: latestEscalation.outcome,
             });
         }
+        async resolveReminderReviewFromOwnerResponse(args) {
+            const reviewMetadata = {
+                [REMINDER_REVIEW_STATUS_METADATA_KEY]: "resolved",
+                [REMINDER_REVIEW_DECISION_METADATA_KEY]: args.resolution,
+                [REMINDER_REVIEW_RESPONDED_AT_METADATA_KEY]: args.respondedAt,
+                [REMINDER_REVIEW_RESPONSE_TEXT_METADATA_KEY]: args.responseText,
+                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.ownerType === "occurrence") {
+                const occurrence = await this.repository.getOccurrence(this.agentId(), args.ownerId);
+                if (occurrence) {
+                    await this.repository.updateOccurrence({
+                        ...occurrence,
+                        metadata: {
+                            ...occurrence.metadata,
+                            reminderAcknowledgedAt: args.respondedAt ?? args.reviewedAt,
+                            reminderAcknowledgedNote: acknowledgementNote,
+                            reminderAcknowledgedResolution: args.resolution,
+                        },
+                        updatedAt: new Date().toISOString(),
+                    });
+                }
+            }
+            else {
+                const event = (await this.repository.listCalendarEvents(this.agentId(), "google")).find((candidate) => candidate.id === args.ownerId);
+                if (event) {
+                    await this.repository.upsertCalendarEvent({
+                        ...event,
+                        metadata: {
+                            ...event.metadata,
+                            reminderAcknowledgedAt: args.respondedAt ?? args.reviewedAt,
+                            reminderAcknowledgedNote: acknowledgementNote,
+                            reminderAcknowledgedResolution: args.resolution,
+                        },
+                        updatedAt: new Date().toISOString(),
+                    });
+                }
+            }
+            await this.resolveReminderEscalation({
+                ownerType: args.ownerType,
+                ownerId: args.ownerId,
+                resolvedAt: args.respondedAt ?? args.reviewedAt,
+                resolution: args.resolution,
+                note: acknowledgementNote,
+            });
+        }
+        async markReminderReviewEscalated(args) {
+            await this.repository.updateReminderAttemptOutcome(args.attempt.id, args.attempt.outcome, {
+                [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,
+            });
+        }
+        async markReminderReviewObservedResponse(args) {
+            await this.repository.updateReminderAttemptOutcome(args.attempt.id, args.attempt.outcome, {
+                [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,
+            });
+        }
         async dispatchDueReminderEscalation(args) {
             if (!shouldDeliverReminderForIntensity(args.intensity, args.urgency)) {
                 return null;
@@ -1702,7 +1785,13 @@ export function withReminders(Base) {
             const lastScheduledPlanTime = Date.parse(lastScheduledPlanEntry.scheduledFor);
             const nowMs = args.now.getTime();
             const planExhausted = nowMs >= lastScheduledPlanTime;
-            if (!planExhausted &&
+            const reviewAttempt = readLatestPendingReminderReviewAttempt(ownerAttempts);
+            const reviewAt = reviewAttempt
+                ? readReminderReviewAt(reviewAttempt)
+                : null;
+            const reviewDue = reviewAt !== null && Date.parse(reviewAt) <= nowMs;
+            if (!reviewDue &&
+                !planExhausted &&
                 !shouldEscalateImmediately(lastNormalAttempt.outcome)) {
                 return null;
             }
@@ -1712,9 +1801,66 @@ export function withReminders(Base) {
             const gatingPlanAttempt = planExhausted
                 ? lastScheduledPlanAttempt
                 : lastNormalAttempt;
-            if (!gatingPlanAttempt && escalationAttempts.length === 0) {
+            if (!reviewDue && !gatingPlanAttempt && escalationAttempts.length === 0) {
+                return null;
+            }
+            const previousAttempt = (reviewDue ? reviewAttempt : null) ??
+                escalationAttempts.at(-1) ??
+                gatingPlanAttempt ??
+                lastNormalAttempt;
+            if (!previousAttempt) {
                 return null;
             }
+            const twilioVoiceAvailable = readTwilioCredentialsFromEnv() !== null;
+            const enforcementState = buildReminderEnforcementState(args.now, args.timezone, args.definition, twilioVoiceAvailable);
+            let forceVoice = enforcementState?.twilioVoiceAvailable &&
+                enforcementState.definitionIsRoutine &&
+                enforcementState.window.kind !== "none" &&
+                enforcementState.minutesPastStart > 20;
+            let scheduledFor = reviewDue ? reviewAt : null;
+            if (!scheduledFor) {
+                const baseDelayMinutes = resolveReminderEscalationDelayMinutes(args.urgency, previousAttempt.outcome, escalationAttempts.length > 0);
+                if (baseDelayMinutes === null) {
+                    return null;
+                }
+                const enforcement = applyEnforcementOverrides(baseDelayMinutes, enforcementState);
+                forceVoice = forceVoice || enforcement.forceVoice;
+                scheduledFor = addMinutes(new Date(previousAttempt.attemptedAt ?? previousAttempt.scheduledFor), enforcement.delayMinutes).toISOString();
+            }
+            if (Date.parse(scheduledFor) > nowMs) {
+                return null;
+            }
+            if (isDeliveredReminderOutcome(previousAttempt.outcome)) {
+                const responseReview = await this.reviewOwnerResponseAfterReminderAttempt({
+                    subjectType: args.subjectType,
+                    attempt: previousAttempt,
+                    now: args.now,
+                });
+                if (responseReview.decision === "explicit_resolution" &&
+                    responseReview.resolution !== null) {
+                    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,
+                    });
+                    return null;
+                }
+                if (reviewDue) {
+                    await this.markReminderReviewObservedResponse({
+                        attempt: previousAttempt,
+                        decision: responseReview.decision,
+                        respondedAt: responseReview.respondedAt,
+                        responseText: responseReview.responseText,
+                        reason: responseReview.reason,
+                    });
+                }
+            }
             const candidateChannels = await this.resolveReminderEscalationChannels({
                 activityProfile: args.activityProfile,
                 policies: args.policies,
@@ -1725,31 +1871,20 @@ export function withReminders(Base) {
             let nextChannel = candidateChannels.find((channel) => !attemptedChannels.has(channel)) ??
                 null;
             if (!nextChannel &&
-                (lastEscalationAttempt?.outcome === "delivered" ||
-                    lastEscalationAttempt?.outcome === "delivered_read" ||
-                    lastEscalationAttempt?.outcome === "delivered_unread") &&
+                lastEscalationAttempt &&
+                isDeliveredReminderOutcome(lastEscalationAttempt.outcome) &&
                 candidateChannels.includes(lastEscalationAttempt.channel)) {
                 nextChannel = lastEscalationAttempt.channel;
             }
-            if (!nextChannel) {
-                return null;
-            }
-            const previousAttempt = escalationAttempts.at(-1) ?? gatingPlanAttempt ?? lastNormalAttempt;
-            if (!previousAttempt) {
-                return null;
-            }
-            const baseDelayMinutes = resolveReminderEscalationDelayMinutes(args.urgency, previousAttempt.outcome, escalationAttempts.length > 0);
-            if (baseDelayMinutes === null) {
-                return null;
+            if (!nextChannel &&
+                isDeliveredReminderOutcome(previousAttempt.outcome) &&
+                candidateChannels.includes(previousAttempt.channel)) {
+                nextChannel = previousAttempt.channel;
             }
-            const twilioVoiceAvailable = readTwilioCredentialsFromEnv() !== null;
-            const enforcementState = buildReminderEnforcementState(args.now, args.timezone, args.definition, twilioVoiceAvailable);
-            const { delayMinutes, forceVoice } = applyEnforcementOverrides(baseDelayMinutes, enforcementState);
             if (forceVoice && nextChannel !== "voice") {
                 nextChannel = "voice";
             }
-            const scheduledFor = addMinutes(new Date(previousAttempt.attemptedAt ?? previousAttempt.scheduledFor), delayMinutes).toISOString();
-            if (Date.parse(scheduledFor) > nowMs) {
+            if (!nextChannel) {
                 return null;
             }
             const attempt = await this.dispatchReminderAttempt({
@@ -1769,14 +1904,24 @@ export function withReminders(Base) {
                 attemptedAt: args.attemptedAt,
                 lifecycle: "escalation",
                 escalationIndex: escalationAttempts.length,
-                escalationReason: escalationAttempts.length > 0
-                    ? "previous_escalation_unacknowledged"
-                    : "plan_exhausted_without_acknowledgement",
+                escalationReason: reviewDue
+                    ? "review_due_without_acknowledgement"
+                    : escalationAttempts.length > 0
+                        ? "previous_escalation_unacknowledged"
+                        : "plan_exhausted_without_acknowledgement",
                 activityProfile: args.activityProfile,
                 nearbyReminderTitles: args.nearbyReminderTitles,
                 timezone: args.timezone,
                 definition: args.definition,
             });
+            if (readReminderReviewAt(previousAttempt) !== null &&
+                !isReminderReviewClosed(previousAttempt)) {
+                await this.markReminderReviewEscalated({
+                    attempt: previousAttempt,
+                    escalatedAttempt: attempt,
+                    escalatedAt: args.attemptedAt,
+                });
+            }
             await this.markReminderEscalationStarted({
                 ownerType: args.ownerType,
                 ownerId: args.ownerId,
@@ -1971,7 +2116,7 @@ export function withReminders(Base) {
                 deliveryMetadata.circadianState = args.activityProfile.circadianState;
             }
             else if (args.channel !== "in_app" &&
-                isWithinQuietHours({
+                isWithinQuietHoursPolicy({
                     now: attemptedAtDate,
                     quietHours: args.quietHours,
                     channel: args.channel,
@@ -2107,6 +2252,21 @@ export function withReminders(Base) {
                         : "unconfigured_channel";
                 }
             }
+            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;
+                if (reviewDelayMinutes !== null) {
+                    deliveryMetadata[REMINDER_REVIEW_AFTER_MINUTES_METADATA_KEY] =
+                        reviewDelayMinutes;
+                    deliveryMetadata[REMINDER_REVIEW_AT_METADATA_KEY] = addMinutes(attemptedAtDate, reviewDelayMinutes).toISOString();
+                    deliveryMetadata[REMINDER_REVIEW_REASON_METADATA_KEY] =
+                        lifecycle === "escalation"
+                            ? "escalation_unacknowledged_review"
+                            : "delivery_acknowledgement_review";
+                }
+            }
             const attempt = createLifeOpsReminderAttempt({
                 agentId: this.agentId(),
                 planId: args.plan.id,
@@ -2471,9 +2631,10 @@ export function withReminders(Base) {
                 const globalReminderPreference = this.buildReminderPreferenceResponse(null, policies);
                 const occurrenceUrgencies = new Map();
                 for (const occurrence of occurrenceViews) {
-                    occurrenceUrgencies.set(occurrence.id, typeof occurrence.metadata.urgency === "string"
-                        ? normalizeReminderUrgency(occurrence.metadata.urgency)
-                        : priorityToUrgency(occurrence.priority));
+                    occurrenceUrgencies.set(occurrence.id, resolveReminderDeliveryUrgency({
+                        metadata: occurrence.metadata,
+                        priority: occurrence.priority,
+                    }));
                 }
                 const plansByEventId = new Map();
                 for (const plan of eventPlans) {
@@ -2484,9 +2645,10 @@ export function withReminders(Base) {
                 }
                 const eventUrgencies = new Map();
                 for (const event of calendarEvents) {
-                    eventUrgencies.set(event.id, typeof event.metadata.urgency === "string"
-                        ? normalizeReminderUrgency(event.metadata.urgency)
-                        : "medium");
+                    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}`;
@@ -2529,6 +2691,7 @@ export function withReminders(Base) {
                         channel: reminder.channel,
                         definition,
                         activityProfile,
+                        urgency,
                     })) {
                         continue;
                     }
@@ -2543,9 +2706,7 @@ export function withReminders(Base) {
                         stepIndex: reminder.stepIndex,
                         scheduledFor: reminder.scheduledFor,
                         dueAt: occurrence.dueAt,
-                        urgency: typeof occurrence.metadata.urgency === "string"
-                            ? normalizeReminderUrgency(occurrence.metadata.urgency)
-                            : priorityToUrgency(occurrence.priority),
+                        urgency,
                         quietHours: plan.quietHours,
                         acknowledged,
                         attemptedAt: now.toISOString(),
@@ -2596,9 +2757,10 @@ export function withReminders(Base) {
                         stepIndex: reminder.stepIndex,
                         scheduledFor: reminder.scheduledFor,
                         dueAt: reminder.dueAt,
-                        urgency: typeof event.metadata.urgency === "string"
-                            ? normalizeReminderUrgency(event.metadata.urgency)
-                            : "medium",
+                        urgency: resolveReminderDeliveryUrgency({
+                            metadata: event.metadata,
+                            fallback: "medium",
+                        }),
                         quietHours: plan.quietHours,
                         acknowledged,
                         attemptedAt: now.toISOString(),
@@ -2641,9 +2803,10 @@ export function withReminders(Base) {
                         subjectType: occurrence.subjectType,
                         title: occurrence.title,
                         dueAt: occurrence.dueAt,
-                        urgency: typeof occurrence.metadata.urgency === "string"
-                            ? normalizeReminderUrgency(occurrence.metadata.urgency)
-                            : priorityToUrgency(occurrence.priority),
+                        urgency: resolveReminderDeliveryUrgency({
+                            metadata: occurrence.metadata,
+                            priority: occurrence.priority,
+                        }),
                         intensity: definitionPreferencesById.get(occurrence.definitionId)?.effective
                             ?.intensity ?? globalReminderPreference.effective.intensity,
                         quietHours: plan.quietHours,
@@ -2683,9 +2846,10 @@ export function withReminders(Base) {
                         subjectType: "owner",
                         title: event.title,
                         dueAt: event.startAt,
-                        urgency: typeof event.metadata.urgency === "string"
-                            ? normalizeReminderUrgency(event.metadata.urgency)
-                            : "medium",
+                        urgency: resolveReminderDeliveryUrgency({
+                            metadata: event.metadata,
+                            fallback: "medium",
+                        }),
                         intensity: globalReminderPreference.effective.intensity,
                         quietHours: plan.quietHours,
                         attemptedAt: now.toISOString(),