@elizaos/plugin-personal-assistant 2.0.3-beta.5 → 2.0.3-beta.7

package/dist/lifeops/service-helpers-reminder.js

@@ -0,0 +1,1186 @@
+import {
+  LIFEOPS_ACTIVITY_SIGNAL_SOURCES,
+  LIFEOPS_ACTIVITY_SIGNAL_STATES,
+  LIFEOPS_REMINDER_CHANNELS,
+  LIFEOPS_REMINDER_INTENSITIES
+} from "../contracts/index.js";
+import {
+  DEFAULT_MORNING_WINDOW,
+  DEFAULT_NIGHT_WINDOW,
+  getCurrentEnforcementWindow,
+  minutesPastWindowStart
+} from "./enforcement-windows.js";
+import {
+  REMINDER_ACTIVITY_GATE_METADATA_KEY,
+  REMINDER_ACTIVITY_GATES,
+  REMINDER_ESCALATION_DELAYS,
+  REMINDER_ESCALATION_PROFILE_METADATA_KEY,
+  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";
+function _isReminderIntensity(value) {
+  return typeof value === "string" && LIFEOPS_REMINDER_INTENSITIES.includes(value);
+}
+function normalizeReminderIntensityInput(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(", ")}`
+    );
+  }
+  return canonical;
+}
+function coerceReminderIntensity(value, field) {
+  const intensity = normalizeOptionalString(value);
+  return intensity ? normalizeReminderIntensityInput(intensity, field) : null;
+}
+function isReminderChannel(value) {
+  return typeof value === "string" && LIFEOPS_REMINDER_CHANNELS.includes(value);
+}
+function isValidIsoString(value) {
+  return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function readReminderReviewAt(attempt) {
+  const reviewAt = attempt.reviewAt ?? null;
+  return isValidIsoString(reviewAt) ? reviewAt : null;
+}
+function readReminderReviewStatus(attempt) {
+  return attempt.reviewStatus ?? null;
+}
+function isReminderReviewClosed(attempt) {
+  const status = readReminderReviewStatus(attempt);
+  return status === "resolved" || status === "escalated" || status === "clarification_requested";
+}
+function normalizeActivitySignalSource(value, field) {
+  const source = requireNonEmptyString(value, field);
+  if (LIFEOPS_ACTIVITY_SIGNAL_SOURCES.includes(
+    source
+  )) {
+    return source;
+  }
+  if (source === "mobileDevice" || source === "mobile-device" || source === "mobileHealth" || source === "mobile-health") {
+    return source.toLowerCase().includes("health") ? "mobile_health" : "mobile_device";
+  }
+  fail(
+    400,
+    `${field} must be one of: ${LIFEOPS_ACTIVITY_SIGNAL_SOURCES.join(", ")}`
+  );
+}
+function normalizeActivitySignalState(value, field) {
+  const state = requireNonEmptyString(value, field);
+  if (LIFEOPS_ACTIVITY_SIGNAL_STATES.includes(
+    state
+  )) {
+    return state;
+  }
+  if (state === "sleep") {
+    return "sleeping";
+  }
+  fail(
+    400,
+    `${field} must be one of: ${LIFEOPS_ACTIVITY_SIGNAL_STATES.join(", ")}`
+  );
+}
+function normalizeOptionalIdleState(value, field) {
+  const idleState = normalizeOptionalString(value);
+  if (!idleState) {
+    return null;
+  }
+  if (idleState === "active" || idleState === "idle" || idleState === "locked" || idleState === "unknown") {
+    return idleState;
+  }
+  fail(400, `${field} must be one of: active, idle, locked, unknown`);
+}
+function mapPlatformToReminderChannel(platform) {
+  const normalized = typeof platform === "string" ? platform.trim() : "";
+  if (!normalized) {
+    return null;
+  }
+  const lower = normalized.toLowerCase();
+  if (lower === "client_chat") {
+    return "in_app";
+  }
+  if (lower === "desktop_app" || lower === "mobile_app" || lower === "web_app") {
+    return "in_app";
+  }
+  if (lower === "telegram-account" || lower === "telegramaccount") {
+    return "telegram";
+  }
+  return isReminderChannel(lower) ? lower : null;
+}
+const DEFAULT_REMINDER_CHANNEL_RANKING_WEIGHTS = {
+  inAppAnchor: 450,
+  activePlatform: 1200,
+  primaryPlatform: 900,
+  secondaryPlatform: 650,
+  lastSeenPlatform: 300,
+  preferredContactChannel: 800,
+  lastResponseChannel: 550,
+  contactSource: 150,
+  ownerContactSource: 100,
+  policyChannel: 75,
+  recencyMax: 120
+};
+const DEFAULT_REMINDER_ESCALATION_PROFILE = {
+  activeWindowOnly: true,
+  requireRoutineDefinition: true,
+  delayCompression: {
+    afterMinutes: 10,
+    factor: 0.5,
+    minMinutes: 1
+  },
+  forceChannel: {
+    channel: "voice",
+    afterMinutes: 20,
+    urgencies: ["critical"],
+    requireAvailable: true
+  }
+};
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readProfileNumber(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function readProfileBoolean(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function readProfileUrgencies(value, fallback) {
+  if (!Array.isArray(value)) {
+    return fallback;
+  }
+  const urgencies = value.filter(
+    (entry) => entry === "low" || entry === "medium" || entry === "high" || entry === "critical"
+  );
+  return urgencies.length > 0 ? urgencies : fallback;
+}
+function readDelayCompressionProfile(value, fallback) {
+  if (value === null) {
+    return null;
+  }
+  if (!isRecord(value)) {
+    return fallback;
+  }
+  const base = fallback ?? DEFAULT_REMINDER_ESCALATION_PROFILE.delayCompression;
+  if (!base) {
+    return null;
+  }
+  return {
+    afterMinutes: Math.max(
+      0,
+      Math.floor(readProfileNumber(value.afterMinutes, base.afterMinutes))
+    ),
+    factor: Math.max(0, readProfileNumber(value.factor, base.factor)),
+    minMinutes: Math.max(
+      1,
+      Math.floor(readProfileNumber(value.minMinutes, base.minMinutes))
+    )
+  };
+}
+function readForceChannelProfile(value, fallback) {
+  if (value === null) {
+    return null;
+  }
+  if (!isRecord(value)) {
+    return fallback;
+  }
+  const base = fallback ?? DEFAULT_REMINDER_ESCALATION_PROFILE.forceChannel;
+  if (!base) {
+    return null;
+  }
+  const channel = isReminderChannel(value.channel) ? value.channel : base.channel;
+  return {
+    channel,
+    afterMinutes: Math.max(
+      0,
+      Math.floor(readProfileNumber(value.afterMinutes, base.afterMinutes))
+    ),
+    urgencies: readProfileUrgencies(value.urgencies, base.urgencies),
+    requireAvailable: readProfileBoolean(
+      value.requireAvailable,
+      base.requireAvailable
+    )
+  };
+}
+function readReminderEscalationProfile(definition) {
+  const raw = definition?.metadata?.[REMINDER_ESCALATION_PROFILE_METADATA_KEY];
+  if (!isRecord(raw)) {
+    return DEFAULT_REMINDER_ESCALATION_PROFILE;
+  }
+  return {
+    activeWindowOnly: readProfileBoolean(
+      raw.activeWindowOnly,
+      DEFAULT_REMINDER_ESCALATION_PROFILE.activeWindowOnly
+    ),
+    requireRoutineDefinition: readProfileBoolean(
+      raw.requireRoutineDefinition,
+      DEFAULT_REMINDER_ESCALATION_PROFILE.requireRoutineDefinition
+    ),
+    delayCompression: readDelayCompressionProfile(
+      raw.delayCompression,
+      DEFAULT_REMINDER_ESCALATION_PROFILE.delayCompression
+    ),
+    forceChannel: readForceChannelProfile(
+      raw.forceChannel,
+      DEFAULT_REMINDER_ESCALATION_PROFILE.forceChannel
+    )
+  };
+}
+function definitionTriggersEnforcement(definition) {
+  if (!definition) return false;
+  if (definition.kind === "routine" || definition.kind === "morning_routine" || definition.kind === "night_routine") {
+    return true;
+  }
+  return definition.metadata.enforceRoutineWindow === true;
+}
+function buildReminderEnforcementState(now, timezone, definition, channelAvailability = {}, windows) {
+  const window = getCurrentEnforcementWindow(
+    now,
+    timezone,
+    windows ?? [DEFAULT_MORNING_WINDOW, DEFAULT_NIGHT_WINDOW]
+  );
+  return {
+    window,
+    minutesPastStart: minutesPastWindowStart(now, timezone, window),
+    definitionIsRoutine: definitionTriggersEnforcement(definition),
+    channelAvailability
+  };
+}
+function resolveReminderEscalationProfileDecision(args) {
+  const profile = args.profile ?? DEFAULT_REMINDER_ESCALATION_PROFILE;
+  let delayMinutes = args.normalDelayMinutes;
+  let forceChannel = null;
+  const state = args.state;
+  if (!state) {
+    return { delayMinutes, forceChannel };
+  }
+  if (profile.activeWindowOnly && state.window.kind === "none") {
+    return { delayMinutes, forceChannel };
+  }
+  if (profile.requireRoutineDefinition && !state.definitionIsRoutine) {
+    return { delayMinutes, forceChannel };
+  }
+  const compression = profile.delayCompression;
+  if (delayMinutes !== null && compression && state.minutesPastStart >= compression.afterMinutes) {
+    delayMinutes = Math.max(
+      compression.minMinutes,
+      Math.floor(delayMinutes * compression.factor)
+    );
+  }
+  const forceProfile = profile.forceChannel;
+  if (forceProfile && state.minutesPastStart >= forceProfile.afterMinutes && forceProfile.urgencies.includes(args.urgency) && (!forceProfile.requireAvailable || state.channelAvailability[forceProfile.channel] === true)) {
+    forceChannel = forceProfile.channel;
+  }
+  return { delayMinutes, forceChannel };
+}
+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, evidence, reason) {
+  if (!channel) {
+    return;
+  }
+  if (!evidenceOrder.has(channel)) {
+    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) {
+    return 0;
+  }
+  const parsed = Date.parse(value);
+  if (!Number.isFinite(parsed)) {
+    return 0;
+  }
+  const ageHours = Math.max(0, (nowMs - parsed) / 36e5);
+  return Math.max(0, maxScore - Math.round(ageHours));
+}
+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" ? args.now : Date.now();
+  const scores = /* @__PURE__ */ new Map();
+  const evidenceOrder = /* @__PURE__ */ new Map();
+  const evidence = /* @__PURE__ */ 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,
+    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,
+      evidence,
+      `owner_preferred_contact:${hint.source}`
+    );
+    addReminderChannelScore(
+      scores,
+      mapPlatformToReminderChannel(hint.lastResponseChannel),
+      weights.lastResponseChannel + 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,
+      evidence,
+      `configured_owner_contact:${source}`
+    );
+  }
+  for (const channel of args.policyChannels) {
+    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) => routingPolicy.includeInApp || channel !== "in_app").sort((left, right) => {
+    const scoreDelta = (scores.get(right) ?? 0) - (scores.get(left) ?? 0);
+    if (scoreDelta !== 0) {
+      return scoreDelta;
+    }
+    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
+  }));
+}
+function rankReminderEscalationChannels(args) {
+  return rankReminderEscalationChannelCandidates(args).map(
+    (candidate) => candidate.channel
+  );
+}
+function readReminderAttemptLifecycle(attempt) {
+  return attempt.deliveryMetadata[REMINDER_LIFECYCLE_METADATA_KEY] === "escalation" ? "escalation" : "plan";
+}
+function shouldEscalateImmediately(outcome) {
+  return outcome === "blocked_connector" || outcome === "blocked_policy" || outcome === "blocked_urgency";
+}
+function shouldDeliverReminderForIntensity(intensity, urgency) {
+  if (intensity === "high_priority_only") {
+    return urgency === "high" || urgency === "critical";
+  }
+  if (intensity === "minimal") {
+    return urgency === "critical";
+  }
+  return true;
+}
+function isComputerPlatform(value) {
+  return value === "desktop_app" || value === "web_app";
+}
+function readReminderActivityGate(definition) {
+  const value = definition?.metadata?.[REMINDER_ACTIVITY_GATE_METADATA_KEY];
+  return REMINDER_ACTIVITY_GATES.includes(value) ? value : null;
+}
+function isActivelyUsingComputer(activityProfile) {
+  if (!activityProfile?.isCurrentlyActive) {
+    return false;
+  }
+  if (isComputerPlatform(activityProfile.lastSeenPlatform)) {
+    return true;
+  }
+  if (activityProfile.lastSeenPlatform === "client_chat") {
+    return isComputerPlatform(activityProfile.primaryPlatform) || isComputerPlatform(activityProfile.secondaryPlatform);
+  }
+  return false;
+}
+function shouldDeferReminderUntilComputerActive(args) {
+  if (args.channel !== "in_app") {
+    return false;
+  }
+  if (args.urgency === "critical") {
+    return false;
+  }
+  if (readReminderActivityGate(args.definition) !== "active_on_computer") {
+    return false;
+  }
+  return !isActivelyUsingComputer(args.activityProfile);
+}
+function isReminderBusyDay(activityProfile) {
+  if (!activityProfile) {
+    return false;
+  }
+  if (activityProfile.screenContextBusy === true) {
+    return true;
+  }
+  if (activityProfile.calendarBusy === true) {
+    return true;
+  }
+  if (typeof activityProfile.avgWeekdayMeetings === "number" && activityProfile.avgWeekdayMeetings >= 4) {
+    return true;
+  }
+  return false;
+}
+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;
+  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];
+}
+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 * 6e4;
+  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
+  };
+}
+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 observation2 = {
+        decision: "needs_clarification",
+        respondedAt: args.responseReview.respondedAt,
+        responseText: args.responseReview.responseText,
+        reason: "snooze_resolution_requires_occurrence_duration",
+        classifierSource: args.responseReview.classifierSource,
+        semanticReason: args.responseReview.semanticReason
+      };
+      return args.reviewDue ? { kind: "clarify", observation: observation2 } : { kind: "escalate", observation: observation2 };
+    }
+    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,
+      classifierSource: args.responseReview.classifierSource,
+      semanticReason: args.responseReview.semanticReason
+    };
+  }
+  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,
+    classifierSource: args.responseReview.classifierSource,
+    semanticReason: args.responseReview.semanticReason
+  };
+  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|tonight)\b/i
+];
+const SKIP_RESPONSE_PATTERNS = [
+  /\b(skip|dismiss|ignore|cancel this|stop this reminder)\b/i
+];
+const COMPLETE_RESPONSE_PATTERNS = [
+  /\b(done|finished|completed|complete|did it|handled|all set)\b/i,
+  /\b(i|we)\s+(did|finished|completed|handled)\b/i
+];
+const ACKNOWLEDGE_RESPONSE_PATTERNS = [
+  /\b(ack|acknowledged|got it|roger|copy|seen|ok|okay|yep|yes)\b/i
+];
+function matchesAnyPattern(value, patterns) {
+  return patterns.some((pattern) => pattern.test(value));
+}
+const TITLE_STOP_WORDS = /* @__PURE__ */ 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 * 6e4;
+}
+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;
+}
+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"
+  };
+}
+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: "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"
+    };
+  }
+  return {
+    decision: "unrelated",
+    resolution: null,
+    snoozeRequest: null,
+    confidence: 0.4,
+    reason: "no_explicit_reminder_resolution"
+  };
+}
+function normalizeSemanticConfidence(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.min(1, value)) : 0.5;
+}
+function normalizeSemanticReason(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim().slice(0, 120) : "semantic_classifier";
+}
+function normalizeSemanticResolution(value) {
+  return value === "acknowledged" || value === "completed" || value === "skipped" || value === "snoozed" ? value : null;
+}
+function normalizeSemanticDecision(value) {
+  return value === "explicit_resolution" || value === "needs_clarification" || value === "unrelated" || value === "abstain" ? value : null;
+}
+function normalizeSemanticSnoozeRequest(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const minutes = value.minutes;
+  if (typeof minutes === "number" && Number.isFinite(minutes) && minutes > 0) {
+    return { minutes: Math.floor(minutes) };
+  }
+  const preset = value.preset;
+  if (preset === "15m" || preset === "30m" || preset === "1h" || preset === "tomorrow_morning" || preset === "tonight") {
+    return { preset };
+  }
+  return null;
+}
+function parseReminderOwnerResponseSemanticClassification(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const decision = normalizeSemanticDecision(value.decision);
+  if (!decision) {
+    return null;
+  }
+  const confidence = normalizeSemanticConfidence(value.confidence);
+  const reason = normalizeSemanticReason(value.reason);
+  if (decision === "abstain") {
+    return {
+      decision,
+      resolution: null,
+      snoozeRequest: null,
+      confidence,
+      reason
+    };
+  }
+  const resolution = decision === "explicit_resolution" ? normalizeSemanticResolution(value.resolution) : null;
+  if (decision === "explicit_resolution" && !resolution) {
+    return null;
+  }
+  const snoozeRequest = resolution === "snoozed" ? normalizeSemanticSnoozeRequest(value.snoozeRequest) : null;
+  return {
+    decision,
+    resolution,
+    snoozeRequest,
+    confidence,
+    reason
+  };
+}
+async function classifyReminderOwnerResponse(args) {
+  const deterministic = classifyReminderOwnerResponseText(
+    args.text,
+    args.context
+  );
+  if (deterministic.decision !== "unrelated" || !args.semanticClassifier) {
+    return { ...deterministic, classifierSource: "deterministic" };
+  }
+  if (args.semanticClassifier) {
+    try {
+      const semantic = await args.semanticClassifier({
+        text: args.text,
+        context: args.context
+      });
+      if (semantic && semantic.decision !== "abstain") {
+        return {
+          ...semantic,
+          classifierSource: "semantic",
+          semanticReason: semantic.reason
+        };
+      }
+      if (semantic?.decision === "abstain") {
+        return {
+          ...deterministic,
+          classifierSource: "semantic_abstain",
+          semanticReason: semantic.reason
+        };
+      }
+    } catch {
+      return {
+        ...deterministic,
+        classifierSource: "semantic_error",
+        semanticReason: "semantic_classifier_error"
+      };
+    }
+  }
+  return { ...deterministic, classifierSource: "deterministic" };
+}
+function normalizeReminderUrgencyValue(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const lower = value.toLowerCase().trim();
+  return lower === "low" || lower === "medium" || lower === "high" || lower === "critical" ? lower : null;
+}
+function resolveReminderDeliveryUrgency(args) {
+  const metadataUrgency = normalizeReminderUrgencyValue(
+    args.metadata?.[REMINDER_URGENCY_METADATA_KEY]
+  ) ?? normalizeReminderUrgencyValue(
+    args.metadata?.[REMINDER_URGENCY_LEGACY_METADATA_KEY]
+  );
+  if (metadataUrgency) {
+    return metadataUrgency;
+  }
+  if (typeof args.priority === "number" && Number.isFinite(args.priority)) {
+    return priorityToUrgency(args.priority);
+  }
+  return args.fallback ?? "medium";
+}
+function resolveReminderEscalationDelayMinutes(urgency, previousOutcome, repeat) {
+  if (shouldEscalateImmediately(previousOutcome)) {
+    return 0;
+  }
+  const delays = REMINDER_ESCALATION_DELAYS[urgency];
+  const base = repeat ? delays.repeatMinutes : delays.initialMinutes;
+  if (base === null) {
+    return null;
+  }
+  if (previousOutcome === "delivered_read") {
+    return Math.max(1, Math.round(base * 0.6));
+  }
+  return base;
+}
+function resolveReminderReviewDelayMinutes(urgency, lifecycle) {
+  const delays = REMINDER_ESCALATION_DELAYS[urgency];
+  return lifecycle === "escalation" ? delays.repeatMinutes : delays.initialMinutes;
+}
+function readReminderPreferenceSettingFromMetadata(metadata, source) {
+  if (!metadata) {
+    return null;
+  }
+  const intensity = coerceReminderIntensity(
+    metadata[REMINDER_INTENSITY_METADATA_KEY],
+    REMINDER_INTENSITY_METADATA_KEY
+  );
+  if (!intensity) {
+    return null;
+  }
+  return {
+    intensity,
+    source,
+    updatedAt: normalizeOptionalIsoString(
+      metadata[REMINDER_INTENSITY_UPDATED_AT_METADATA_KEY],
+      REMINDER_INTENSITY_UPDATED_AT_METADATA_KEY
+    ) ?? null,
+    note: normalizeOptionalString(metadata[REMINDER_INTENSITY_NOTE_METADATA_KEY]) ?? null
+  };
+}
+function withReminderPreferenceMetadata(current, intensity, updatedAt, note, scope) {
+  return mergeMetadata(current, {
+    [REMINDER_INTENSITY_METADATA_KEY]: intensity,
+    [REMINDER_INTENSITY_UPDATED_AT_METADATA_KEY]: updatedAt,
+    [REMINDER_INTENSITY_NOTE_METADATA_KEY]: note,
+    [REMINDER_PREFERENCE_SCOPE_METADATA_KEY]: scope
+  });
+}
+function applyReminderIntensityToPlan(plan, intensity) {
+  const steps = plan.steps.map((step) => ({ ...step }));
+  if (intensity === "minimal") {
+    return {
+      ...plan,
+      steps: steps.slice(0, 1)
+    };
+  }
+  if (intensity === "persistent") {
+    const lastStep = steps[steps.length - 1] ?? {
+      channel: "in_app",
+      offsetMinutes: 0,
+      label: "Reminder"
+    };
+    const extraStepOffset = lastStep.offsetMinutes + 60;
+    if (!steps.some(
+      (step) => step.channel === "in_app" && step.offsetMinutes === extraStepOffset
+    )) {
+      steps.push({
+        channel: "in_app",
+        offsetMinutes: extraStepOffset,
+        label: `${lastStep.label} follow-up`
+      });
+      steps.sort((left, right) => left.offsetMinutes - right.offsetMinutes);
+    }
+  }
+  return {
+    ...plan,
+    steps
+  };
+}
+export {
+  DEFAULT_REMINDER_ESCALATION_PROFILE,
+  _isReminderIntensity,
+  applyReminderIntensityToPlan,
+  buildReminderEnforcementState,
+  buildReminderResponseClaim,
+  classifyReminderOwnerResponse,
+  classifyReminderOwnerResponseText,
+  coerceReminderIntensity,
+  decideReminderReviewTransition,
+  definitionTriggersEnforcement,
+  isReminderBusyDay,
+  isReminderChannel,
+  isReminderReviewClosed,
+  mapPlatformToReminderChannel,
+  normalizeActivitySignalSource,
+  normalizeActivitySignalState,
+  normalizeOptionalIdleState,
+  normalizeReminderIntensityInput,
+  normalizeReminderUrgencyValue,
+  parseReminderOwnerResponseSemanticClassification,
+  parseReminderSnoozeRequestFromText,
+  rankReminderEscalationChannelCandidates,
+  rankReminderEscalationChannels,
+  readReminderActivityGate,
+  readReminderAttemptLifecycle,
+  readReminderEscalationProfile,
+  readReminderPreferenceSettingFromMetadata,
+  readReminderReviewAt,
+  readReminderReviewStatus,
+  resolveReminderDeliveryUrgency,
+  resolveReminderEscalationDelayMinutes,
+  resolveReminderEscalationProfileDecision,
+  resolveReminderEscalationRoutingPolicy,
+  resolveReminderReviewDelayMinutes,
+  shouldDeferReminderUntilComputerActive,
+  shouldDeliverReminderForIntensity,
+  shouldEscalateImmediately,
+  withReminderPreferenceMetadata
+};
+//# sourceMappingURL=service-helpers-reminder.js.map