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

package/apps/app-lifeops/src/lifeops/service-helpers-reminder.js

@@ -1,5 +1,5 @@
 import { LIFEOPS_ACTIVITY_SIGNAL_SOURCES, LIFEOPS_ACTIVITY_SIGNAL_STATES, LIFEOPS_REMINDER_CHANNELS, LIFEOPS_REMINDER_INTENSITIES, } from "../contracts/index.js";
-import { REMINDER_ACTIVITY_GATE_METADATA_KEY, REMINDER_ESCALATION_DELAYS, REMINDER_INTENSITY_CANONICAL_ALIASES, 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_URGENCY_LEGACY_METADATA_KEY, REMINDER_URGENCY_METADATA_KEY, } from "./service-constants.js";
+import { REMINDER_ACTIVITY_GATE_METADATA_KEY, REMINDER_ACTIVITY_GATES, REMINDER_ESCALATION_DELAYS, REMINDER_INTENSITY_CANONICAL_ALIASES, 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_URGENCY_LEGACY_METADATA_KEY, REMINDER_URGENCY_METADATA_KEY, } from "./service-constants.js";
 import { mergeMetadata, priorityToUrgency } from "./service-helpers-misc.js";
 import { fail, normalizeOptionalIsoString, normalizeOptionalString, requireNonEmptyString, } from "./service-normalize.js";
 export function _isReminderIntensity(value) {
@@ -7,7 +7,7 @@ export function _isReminderIntensity(value) {
         LIFEOPS_REMINDER_INTENSITIES.includes(value));
 }
 export function normalizeReminderIntensityInput(value, field) {
-    const intensity = requireNonEmptyString(value, field);
+    const intensity = requireNonEmptyString(value, field).toLowerCase();
     const canonical = REMINDER_INTENSITY_CANONICAL_ALIASES[intensity];
     if (!canonical) {
         fail(400, `${field} must be one of: ${LIFEOPS_REMINDER_INTENSITIES.join(", ")}`);
@@ -22,6 +22,22 @@ export function isReminderChannel(value) {
     return (typeof value === "string" &&
         LIFEOPS_REMINDER_CHANNELS.includes(value));
 }
+function isValidIsoString(value) {
+    return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+export function readReminderReviewAt(attempt) {
+    const reviewAt = attempt.reviewAt ?? null;
+    return isValidIsoString(reviewAt) ? reviewAt : null;
+}
+export function readReminderReviewStatus(attempt) {
+    return attempt.reviewStatus ?? null;
+}
+export function isReminderReviewClosed(attempt) {
+    const status = readReminderReviewStatus(attempt);
+    return (status === "resolved" ||
+        status === "escalated" ||
+        status === "clarification_requested");
+}
 export function normalizeActivitySignalSource(value, field) {
     const source = requireNonEmptyString(value, field);
     if (LIFEOPS_ACTIVITY_SIGNAL_SOURCES.includes(source)) {
@@ -80,7 +96,7 @@ export function mapPlatformToReminderChannel(platform) {
     return isReminderChannel(lower) ? lower : null;
 }
 const DEFAULT_REMINDER_CHANNEL_RANKING_WEIGHTS = {
-    inAppAnchor: 10_000,
+    inAppAnchor: 450,
     activePlatform: 1_200,
     primaryPlatform: 900,
     secondaryPlatform: 650,
@@ -92,12 +108,58 @@ const DEFAULT_REMINDER_CHANNEL_RANKING_WEIGHTS = {
     policyChannel: 75,
     recencyMax: 120,
 };
-function resolveReminderChannelRankingWeights(overrides) {
-    return overrides
-        ? { ...DEFAULT_REMINDER_CHANNEL_RANKING_WEIGHTS, ...overrides }
-        : DEFAULT_REMINDER_CHANNEL_RANKING_WEIGHTS;
+export function resolveReminderEscalationRoutingPolicy(args) {
+    const urgency = args.urgency ?? "medium";
+    const screenContextUsable = args.activityProfile?.screenContextAvailable === true &&
+        args.activityProfile.screenContextStale !== true &&
+        (args.activityProfile.screenContextConfidence ?? 1) >= 0.5;
+    const screenBusy = screenContextUsable && args.activityProfile?.screenContextBusy === true;
+    const attentionBusy = screenBusy ||
+        args.activityProfile?.calendarBusy === true ||
+        args.activityProfile?.dndActive === true;
+    const ownerActive = args.activityProfile?.isCurrentlyActive === true;
+    const activeChannel = mapPlatformToReminderChannel(ownerActive ? args.activityProfile?.lastSeenPlatform : null);
+    const interruptionBudget = urgency === "critical"
+        ? "urgent"
+        : urgency === "high"
+            ? "elevated"
+            : attentionBusy
+                ? "low"
+                : "normal";
+    const urgencyWeight = urgency === "critical" ? 350 : urgency === "high" ? 220 : 0;
+    const busyInAppBias = attentionBusy && urgency !== "critical" ? 450 : 0;
+    const inactiveInAppPenalty = ownerActive ? 0 : -250;
+    const activeInAppBias = activeChannel === "in_app" || activeChannel === null ? 250 : 0;
+    const weights = {
+        ...DEFAULT_REMINDER_CHANNEL_RANKING_WEIGHTS,
+        inAppAnchor: Math.max(50, DEFAULT_REMINDER_CHANNEL_RANKING_WEIGHTS.inAppAnchor +
+            busyInAppBias +
+            inactiveInAppPenalty +
+            activeInAppBias),
+        preferredContactChannel: DEFAULT_REMINDER_CHANNEL_RANKING_WEIGHTS.preferredContactChannel +
+            urgencyWeight,
+        lastResponseChannel: DEFAULT_REMINDER_CHANNEL_RANKING_WEIGHTS.lastResponseChannel +
+            Math.round(urgencyWeight * 0.7),
+        policyChannel: DEFAULT_REMINDER_CHANNEL_RANKING_WEIGHTS.policyChannel +
+            Math.round(urgencyWeight * 0.4),
+        ...args.weights,
+    };
+    return {
+        includeInApp: args.includeInApp !== false,
+        interruptionBudget,
+        weights,
+        reason: args.activityProfile?.dndActive === true
+            ? "do_not_disturb"
+            : args.activityProfile?.calendarBusy === true
+                ? "calendar_busy"
+                : screenBusy
+                    ? "screen_context_busy"
+                    : ownerActive
+                        ? "owner_currently_active"
+                        : "owner_recent_channel_history",
+    };
 }
-function addReminderChannelScore(scores, channel, score, evidenceOrder) {
+function addReminderChannelScore(scores, channel, score, evidenceOrder, evidence, reason) {
     if (!channel) {
         return;
     }
@@ -105,6 +167,11 @@ function addReminderChannelScore(scores, channel, score, evidenceOrder) {
         evidenceOrder.set(channel, evidenceOrder.size);
     }
     scores.set(channel, (scores.get(channel) ?? 0) + score);
+    if (evidence && reason) {
+        const reasons = evidence.get(channel) ?? [];
+        reasons.push(reason);
+        evidence.set(channel, reasons);
+    }
 }
 function lastResponseRecencyScore(value, nowMs, maxScore) {
     if (!value) {
@@ -117,8 +184,15 @@ function lastResponseRecencyScore(value, nowMs, maxScore) {
     const ageHours = Math.max(0, (nowMs - parsed) / 3_600_000);
     return Math.max(0, maxScore - Math.round(ageHours));
 }
-export function rankReminderEscalationChannels(args) {
-    const weights = resolveReminderChannelRankingWeights(args.weights);
+export function rankReminderEscalationChannelCandidates(args) {
+    const routingPolicy = args.routingPolicy ??
+        resolveReminderEscalationRoutingPolicy({
+            activityProfile: args.activityProfile,
+            urgency: args.urgency,
+            includeInApp: args.includeInApp,
+            weights: args.weights,
+        });
+    const weights = routingPolicy.weights;
     const nowMs = args.now instanceof Date
         ? args.now.getTime()
         : typeof args.now === "number"
@@ -126,28 +200,33 @@ export function rankReminderEscalationChannels(args) {
             : Date.now();
     const scores = new Map();
     const evidenceOrder = new Map();
-    if (args.includeInApp !== false) {
-        addReminderChannelScore(scores, "in_app", weights.inAppAnchor, evidenceOrder);
+    const evidence = new Map();
+    if (routingPolicy.includeInApp) {
+        addReminderChannelScore(scores, "in_app", weights.inAppAnchor, evidenceOrder, evidence, "default_in_app_surface");
     }
     const activity = args.activityProfile;
-    addReminderChannelScore(scores, mapPlatformToReminderChannel(activity?.isCurrentlyActive ? activity.lastSeenPlatform : null), weights.activePlatform, evidenceOrder);
-    addReminderChannelScore(scores, mapPlatformToReminderChannel(activity?.primaryPlatform), weights.primaryPlatform, evidenceOrder);
-    addReminderChannelScore(scores, mapPlatformToReminderChannel(activity?.secondaryPlatform), weights.secondaryPlatform, evidenceOrder);
-    addReminderChannelScore(scores, mapPlatformToReminderChannel(activity?.lastSeenPlatform), weights.lastSeenPlatform, evidenceOrder);
+    addReminderChannelScore(scores, mapPlatformToReminderChannel(activity?.isCurrentlyActive ? activity.lastSeenPlatform : null), weights.activePlatform, evidenceOrder, evidence, "currently_active_platform");
+    addReminderChannelScore(scores, mapPlatformToReminderChannel(activity?.primaryPlatform), weights.primaryPlatform, evidenceOrder, evidence, "primary_platform");
+    addReminderChannelScore(scores, mapPlatformToReminderChannel(activity?.secondaryPlatform), weights.secondaryPlatform, evidenceOrder, evidence, "secondary_platform");
+    addReminderChannelScore(scores, mapPlatformToReminderChannel(activity?.lastSeenPlatform), weights.lastSeenPlatform, evidenceOrder, evidence, "last_seen_platform");
     for (const hint of Object.values(args.ownerContactHints)) {
-        addReminderChannelScore(scores, mapPlatformToReminderChannel(hint.preferredCommunicationChannel), weights.preferredContactChannel, evidenceOrder);
+        addReminderChannelScore(scores, mapPlatformToReminderChannel(hint.preferredCommunicationChannel), weights.preferredContactChannel, evidenceOrder, evidence, `owner_preferred_contact:${hint.source}`);
         addReminderChannelScore(scores, mapPlatformToReminderChannel(hint.lastResponseChannel), weights.lastResponseChannel +
-            lastResponseRecencyScore(hint.lastResponseAt, nowMs, weights.recencyMax), evidenceOrder);
-        addReminderChannelScore(scores, mapPlatformToReminderChannel(hint.source), weights.contactSource, evidenceOrder);
+            lastResponseRecencyScore(hint.lastResponseAt, nowMs, weights.recencyMax), evidenceOrder, evidence, `recent_owner_response:${hint.source}`);
+        addReminderChannelScore(scores, mapPlatformToReminderChannel(hint.source), weights.contactSource, evidenceOrder, evidence, `contact_source:${hint.source}`);
     }
     for (const source of args.ownerContactSources) {
-        addReminderChannelScore(scores, mapPlatformToReminderChannel(source), weights.ownerContactSource, evidenceOrder);
+        addReminderChannelScore(scores, mapPlatformToReminderChannel(source), weights.ownerContactSource, evidenceOrder, evidence, `configured_owner_contact:${source}`);
     }
     for (const channel of args.policyChannels) {
-        addReminderChannelScore(scores, mapPlatformToReminderChannel(channel), weights.policyChannel, evidenceOrder);
+        const reminderChannel = mapPlatformToReminderChannel(channel);
+        addReminderChannelScore(scores, reminderChannel, weights.policyChannel +
+            (reminderChannel
+                ? (args.policyChannelWeightAdjustments?.[reminderChannel] ?? 0)
+                : 0), evidenceOrder, evidence, `channel_policy:${channel}`);
     }
     return [...scores.keys()]
-        .filter((channel) => args.includeInApp !== false || channel !== "in_app")
+        .filter((channel) => routingPolicy.includeInApp || channel !== "in_app")
         .sort((left, right) => {
         const scoreDelta = (scores.get(right) ?? 0) - (scores.get(left) ?? 0);
         if (scoreDelta !== 0) {
@@ -156,7 +235,17 @@ export function rankReminderEscalationChannels(args) {
         const orderDelta = (evidenceOrder.get(left) ?? Number.MAX_SAFE_INTEGER) -
             (evidenceOrder.get(right) ?? Number.MAX_SAFE_INTEGER);
         return orderDelta !== 0 ? orderDelta : left.localeCompare(right);
-    });
+    })
+        .map((channel) => ({
+        channel,
+        score: scores.get(channel) ?? 0,
+        evidence: evidence.get(channel) ?? [],
+        vetoReasons: [],
+        interruptionBudget: routingPolicy.interruptionBudget,
+    }));
+}
+export function rankReminderEscalationChannels(args) {
+    return rankReminderEscalationChannelCandidates(args).map((candidate) => candidate.channel);
 }
 export function readReminderAttemptLifecycle(attempt) {
     return attempt.deliveryMetadata[REMINDER_LIFECYCLE_METADATA_KEY] ===
@@ -167,7 +256,6 @@ export function readReminderAttemptLifecycle(attempt) {
 export function shouldEscalateImmediately(outcome) {
     return (outcome === "blocked_connector" ||
         outcome === "blocked_policy" ||
-        outcome === "blocked_quiet_hours" ||
         outcome === "blocked_urgency");
 }
 export function shouldDeliverReminderForIntensity(intensity, urgency) {
@@ -184,7 +272,9 @@ function isComputerPlatform(value) {
 }
 export function readReminderActivityGate(definition) {
     const value = definition?.metadata?.[REMINDER_ACTIVITY_GATE_METADATA_KEY];
-    return value === "active_on_computer" ? value : null;
+    return REMINDER_ACTIVITY_GATES.includes(value)
+        ? value
+        : null;
 }
 function isActivelyUsingComputer(activityProfile) {
     if (!activityProfile?.isCurrentlyActive) {
@@ -203,7 +293,7 @@ export function shouldDeferReminderUntilComputerActive(args) {
     if (args.channel !== "in_app") {
         return false;
     }
-    if (args.urgency === "high" || args.urgency === "critical") {
+    if (args.urgency === "critical") {
         return false;
     }
     if (readReminderActivityGate(args.definition) !== "active_on_computer") {
@@ -211,9 +301,131 @@ export function shouldDeferReminderUntilComputerActive(args) {
     }
     return !isActivelyUsingComputer(args.activityProfile);
 }
+function readReminderAttemptDeliveryRoomId(attempt, roomIds) {
+    const explicitRoomId = attempt.deliveryMetadata.deliveryRoomId;
+    if (typeof explicitRoomId === "string" && roomIds.includes(explicitRoomId)) {
+        return explicitRoomId;
+    }
+    const routeEndpoint = attempt.deliveryMetadata.routeEndpoint;
+    return typeof routeEndpoint === "string" && roomIds.includes(routeEndpoint)
+        ? routeEndpoint
+        : null;
+}
+function readReminderAttemptAttemptedMs(attempt) {
+    const attemptedAt = attempt.attemptedAt ?? attempt.scheduledFor ?? null;
+    const attemptedMs = attemptedAt ? Date.parse(attemptedAt) : Number.NaN;
+    return Number.isFinite(attemptedMs) ? attemptedMs : null;
+}
+function reminderAttemptMatchesResponseRoom(args) {
+    const deliveryRoomId = readReminderAttemptDeliveryRoomId(args.attempt, args.roomIds);
+    if (deliveryRoomId) {
+        return args.responseRoomId === deliveryRoomId;
+    }
+    return (args.roomIds.length === 1 &&
+        args.attempt.channel === "in_app" &&
+        args.responseRoomId === args.roomIds[0]);
+}
+export function buildReminderResponseClaim(args) {
+    const deliveryRoomId = readReminderAttemptDeliveryRoomId(args.attempt, args.roomIds);
+    const baseClaim = {
+        attemptId: args.attempt.id,
+        responseText: args.response.text,
+        responseCreatedAt: args.response.createdAt,
+        responseRoomId: args.response.roomId,
+        deliveryRoomId,
+    };
+    if (!reminderAttemptMatchesResponseRoom({
+        attempt: args.attempt,
+        responseRoomId: args.response.roomId,
+        roomIds: args.roomIds,
+    })) {
+        return {
+            ...baseClaim,
+            binding: "wrong_thread",
+            allowStandaloneResolution: false,
+        };
+    }
+    const promptWindowMs = 10 * 60_000;
+    const candidates = args.competingAttempts
+        .filter((attempt) => ["delivered", "delivered_read", "delivered_unread"].includes(attempt.outcome))
+        .filter((attempt) => !isReminderReviewClosed(attempt))
+        .filter((attempt) => reminderAttemptMatchesResponseRoom({
+        attempt,
+        responseRoomId: args.response.roomId,
+        roomIds: args.roomIds,
+    }))
+        .map((attempt) => ({
+        attempt,
+        attemptedMs: readReminderAttemptAttemptedMs(attempt),
+    }))
+        .filter((candidate) => candidate.attemptedMs !== null &&
+        candidate.attemptedMs <= args.response.createdAt &&
+        args.response.createdAt - candidate.attemptedMs <= promptWindowMs);
+    if (candidates.length === 0) {
+        return {
+            ...baseClaim,
+            binding: deliveryRoomId ? "delivery_thread" : "single_in_app_room",
+            allowStandaloneResolution: true,
+        };
+    }
+    const latestAttemptedMs = Math.max(...candidates.map((candidate) => candidate.attemptedMs));
+    const latestCandidates = candidates.filter((candidate) => candidate.attemptedMs === latestAttemptedMs);
+    const isOnlyLatest = latestCandidates.length === 1 &&
+        latestCandidates[0]?.attempt.id === args.attempt.id;
+    return {
+        ...baseClaim,
+        binding: isOnlyLatest
+            ? "latest_prompt_in_thread"
+            : "stale_or_competing_prompt",
+        allowStandaloneResolution: isOnlyLatest,
+    };
+}
+export function decideReminderReviewTransition(args) {
+    if (args.responseReview.decision === "explicit_resolution" &&
+        args.responseReview.resolution !== null) {
+        if (args.responseReview.resolution === "snoozed" &&
+            (args.ownerType !== "occurrence" || !args.responseReview.snoozeRequest)) {
+            const observation = {
+                decision: "needs_clarification",
+                respondedAt: args.responseReview.respondedAt,
+                responseText: args.responseReview.responseText,
+                reason: "snooze_resolution_requires_occurrence_duration",
+            };
+            return args.reviewDue
+                ? { kind: "clarify", observation }
+                : { kind: "escalate", observation };
+        }
+        return {
+            kind: "resolve",
+            resolution: args.responseReview.resolution,
+            responseText: args.responseReview.responseText,
+            respondedAt: args.responseReview.respondedAt,
+            snoozeRequest: args.responseReview.snoozeRequest,
+            confidence: args.responseReview.confidence,
+            reason: args.responseReview.reason,
+        };
+    }
+    if (!args.reviewDue) {
+        return { kind: "wait" };
+    }
+    const observation = {
+        decision: args.responseReview.decision === "needs_clarification"
+            ? "needs_clarification"
+            : args.responseReview.decision === "no_response"
+                ? "no_response"
+                : "unrelated",
+        respondedAt: args.responseReview.respondedAt,
+        responseText: args.responseReview.responseText,
+        reason: args.responseReview.reason,
+    };
+    return args.responseReview.decision === "needs_clarification"
+        ? { kind: "clarify", observation }
+        : { kind: "escalate", observation };
+}
 const SNOOZE_RESPONSE_PATTERNS = [
+    /^\s*\d{1,3}\s*(m|min|mins|minute|minutes|h|hr|hrs|hour|hours)\s*$/i,
     /\b(snooze|remind me later|later|not now|in a bit)\b/i,
-    /\b(remind me|ping me|nudge me)\s+(in|at|after|tomorrow)\b/i,
+    /\b(remind me|ping me|nudge me)\s+(in|at|after|tomorrow|tonight)\b/i,
 ];
 const SKIP_RESPONSE_PATTERNS = [
     /\b(skip|dismiss|ignore|cancel this|stop this reminder)\b/i,
@@ -228,44 +440,297 @@ const ACKNOWLEDGE_RESPONSE_PATTERNS = [
 function matchesAnyPattern(value, patterns) {
     return patterns.some((pattern) => pattern.test(value));
 }
-export function classifyReminderOwnerResponseText(text) {
+const TITLE_STOP_WORDS = new Set([
+    "a",
+    "an",
+    "and",
+    "for",
+    "me",
+    "my",
+    "of",
+    "the",
+    "this",
+    "to",
+]);
+function tokenizeReminderText(value) {
+    return value
+        .toLowerCase()
+        .split(/[^a-z0-9]+/u)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 2 && !TITLE_STOP_WORDS.has(token));
+}
+function responseReferencesReminder(text, context) {
+    const lower = text.toLowerCase();
+    if (/\b(this|that|the)\s+reminder\b/u.test(lower)) {
+        return true;
+    }
+    if (/\b(reminder|nudge|ping)\b/u.test(lower)) {
+        return true;
+    }
+    const titleTokens = tokenizeReminderText(context?.title ?? "");
+    if (titleTokens.length === 0) {
+        return false;
+    }
+    const responseTokens = new Set(tokenizeReminderText(text));
+    const matchingTokenCount = titleTokens.filter((token) => responseTokens.has(token)).length;
+    if (titleTokens.length === 1) {
+        return matchingTokenCount === 1 && titleTokens[0].length >= 4;
+    }
+    if (titleTokens.length === 2) {
+        return matchingTokenCount === 2;
+    }
+    return matchingTokenCount >= 2;
+}
+function resolveResponseTimestampMs(value) {
+    if (value instanceof Date) {
+        return value.getTime();
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+        const parsed = Date.parse(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+function isPromptAdjacentResponse(context) {
+    if (!context) {
+        return true;
+    }
+    if (!context.attemptedAt || !context.respondedAt) {
+        return false;
+    }
+    const attemptedMs = Date.parse(context.attemptedAt);
+    const respondedMs = resolveResponseTimestampMs(context.respondedAt);
+    if (!Number.isFinite(attemptedMs) || respondedMs === null) {
+        return false;
+    }
+    const deltaMs = respondedMs - attemptedMs;
+    return deltaMs >= 0 && deltaMs <= 10 * 60_000;
+}
+function normalizeStandaloneResponse(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[.!]+$/u, "")
+        .replace(/\s+/gu, " ");
+}
+function isStandaloneResolutionResponse(value) {
+    const normalized = normalizeStandaloneResponse(value);
+    if (/^\d{1,3}\s*(m|min|mins|minute|minutes|h|hr|hrs|hour|hours)$/iu.test(normalized)) {
+        return true;
+    }
+    if (/^(remind me|ping me|nudge me)\s+(at|after|tomorrow)\b/iu.test(normalized)) {
+        return true;
+    }
+    return (normalized === "done" ||
+        normalized === "finished" ||
+        normalized === "completed" ||
+        normalized === "complete" ||
+        normalized === "did it" ||
+        normalized === "handled" ||
+        normalized === "all set" ||
+        normalized === "skip" ||
+        normalized === "dismiss" ||
+        normalized === "cancel this" ||
+        normalized === "ack" ||
+        normalized === "acknowledged" ||
+        normalized === "got it" ||
+        normalized === "roger" ||
+        normalized === "copy" ||
+        normalized === "seen" ||
+        normalized === "ok" ||
+        normalized === "okay" ||
+        normalized === "yep" ||
+        normalized === "yes" ||
+        normalized === "snooze" ||
+        normalized === "later" ||
+        normalized === "not now" ||
+        normalized === "in a bit" ||
+        normalized === "remind me later");
+}
+function isResponseBoundToReminder(text, context) {
+    if (!context) {
+        return true;
+    }
+    if (responseReferencesReminder(text, context)) {
+        return true;
+    }
+    if (context.allowStandaloneResolution === false) {
+        return false;
+    }
+    return (isPromptAdjacentResponse(context) && isStandaloneResolutionResponse(text));
+}
+function toSnoozeMinutes(value, unit) {
+    const amount = Number.parseInt(value, 10);
+    if (!Number.isFinite(amount) || amount <= 0) {
+        return null;
+    }
+    const normalizedUnit = unit.toLowerCase();
+    if (normalizedUnit === "h" ||
+        normalizedUnit === "hr" ||
+        normalizedUnit === "hrs" ||
+        normalizedUnit === "hour" ||
+        normalizedUnit === "hours") {
+        return amount * 60;
+    }
+    return amount;
+}
+export function parseReminderSnoozeRequestFromText(text) {
+    const cleaned = text.trim().toLowerCase();
+    if (/\btomorrow\s+morning\b/u.test(cleaned)) {
+        return {
+            request: { preset: "tomorrow_morning" },
+            needsClarification: false,
+            reason: "snooze_tomorrow_morning",
+        };
+    }
+    if (/\btonight\b/u.test(cleaned)) {
+        return {
+            request: { preset: "tonight" },
+            needsClarification: false,
+            reason: "snooze_tonight",
+        };
+    }
+    const durationMatch = cleaned.match(/\b(?:in|after|for)?\s*(\d{1,3})\s*(m|min|mins|minute|minutes|h|hr|hrs|hour|hours)\b/u);
+    if (durationMatch) {
+        const minutes = toSnoozeMinutes(durationMatch[1] ?? "", durationMatch[2] ?? "");
+        if (minutes !== null) {
+            if (minutes === 15) {
+                return {
+                    request: { preset: "15m" },
+                    needsClarification: false,
+                    reason: "snooze_15m",
+                };
+            }
+            if (minutes === 30) {
+                return {
+                    request: { preset: "30m" },
+                    needsClarification: false,
+                    reason: "snooze_30m",
+                };
+            }
+            if (minutes === 60) {
+                return {
+                    request: { preset: "1h" },
+                    needsClarification: false,
+                    reason: "snooze_1h",
+                };
+            }
+            return {
+                request: { minutes },
+                needsClarification: false,
+                reason: "snooze_duration",
+            };
+        }
+    }
+    const vagueSnooze = /\b(snooze|later|not now|in a bit|some other time)\b/u.test(cleaned) ||
+        /\b(remind me|ping me|nudge me)\s+(at|after|tomorrow)\b/u.test(cleaned);
+    return {
+        request: null,
+        needsClarification: vagueSnooze,
+        reason: vagueSnooze ? "snooze_needs_duration" : "no_snooze_request",
+    };
+}
+export function classifyReminderOwnerResponseText(text, context) {
     const cleaned = text.trim();
     if (cleaned.length === 0) {
         return {
             decision: "unrelated",
             resolution: null,
+            snoozeRequest: null,
             confidence: 0,
             reason: "empty_response",
         };
     }
     if (matchesAnyPattern(cleaned, SNOOZE_RESPONSE_PATTERNS)) {
+        if (!isResponseBoundToReminder(cleaned, context)) {
+            return {
+                decision: "unrelated",
+                resolution: null,
+                snoozeRequest: null,
+                confidence: 0.35,
+                reason: "snooze_language_not_bound_to_reminder",
+            };
+        }
+        const snooze = parseReminderSnoozeRequestFromText(cleaned);
+        if (snooze.request) {
+            return {
+                decision: "explicit_resolution",
+                resolution: "snoozed",
+                snoozeRequest: snooze.request,
+                confidence: 0.86,
+                reason: snooze.reason,
+            };
+        }
+        if (snooze.needsClarification) {
+            return {
+                decision: "needs_clarification",
+                resolution: null,
+                snoozeRequest: null,
+                confidence: 0.68,
+                reason: snooze.reason,
+            };
+        }
         return {
-            decision: "explicit_resolution",
-            resolution: "snoozed",
-            confidence: 0.82,
-            reason: "snooze_language",
+            decision: "needs_clarification",
+            resolution: null,
+            snoozeRequest: null,
+            confidence: 0.62,
+            reason: "snooze_needs_duration",
         };
     }
     if (matchesAnyPattern(cleaned, SKIP_RESPONSE_PATTERNS)) {
+        if (!isResponseBoundToReminder(cleaned, context)) {
+            return {
+                decision: "unrelated",
+                resolution: null,
+                snoozeRequest: null,
+                confidence: 0.35,
+                reason: "skip_language_not_bound_to_reminder",
+            };
+        }
         return {
             decision: "explicit_resolution",
             resolution: "skipped",
+            snoozeRequest: null,
             confidence: 0.82,
             reason: "skip_language",
         };
     }
     if (matchesAnyPattern(cleaned, COMPLETE_RESPONSE_PATTERNS)) {
+        if (!isResponseBoundToReminder(cleaned, context)) {
+            return {
+                decision: "unrelated",
+                resolution: null,
+                snoozeRequest: null,
+                confidence: 0.35,
+                reason: "completion_language_not_bound_to_reminder",
+            };
+        }
         return {
             decision: "explicit_resolution",
             resolution: "completed",
+            snoozeRequest: null,
             confidence: 0.86,
             reason: "completion_language",
         };
     }
     if (matchesAnyPattern(cleaned, ACKNOWLEDGE_RESPONSE_PATTERNS)) {
+        if (!isResponseBoundToReminder(cleaned, context)) {
+            return {
+                decision: "unrelated",
+                resolution: null,
+                snoozeRequest: null,
+                confidence: 0.3,
+                reason: "acknowledgement_language_not_bound_to_reminder",
+            };
+        }
         return {
             decision: "explicit_resolution",
             resolution: "acknowledged",
+            snoozeRequest: null,
             confidence: 0.74,
             reason: "acknowledgement_language",
         };
@@ -273,6 +738,7 @@ export function classifyReminderOwnerResponseText(text) {
     return {
         decision: "unrelated",
         resolution: null,
+        snoozeRequest: null,
         confidence: 0.4,
         reason: "no_explicit_reminder_resolution",
     };
@@ -321,6 +787,12 @@ export function resolveReminderEscalationDelayMinutes(urgency, previousOutcome,
     }
     return base;
 }
+export function resolveReminderReviewDelayMinutes(urgency, lifecycle) {
+    const delays = REMINDER_ESCALATION_DELAYS[urgency];
+    return lifecycle === "escalation"
+        ? delays.repeatMinutes
+        : delays.initialMinutes;
+}
 export function readReminderPreferenceSettingFromMetadata(metadata, source) {
     if (!metadata) {
         return null;