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

package/dist/actions/life.js

@@ -0,0 +1,2524 @@
+import {
+  extractConversationMetadataFromRoom,
+  isPageScopedConversationMetadata,
+  renderGroundedActionReply
+} from "@elizaos/agent";
+import { resolveActionArgs } from "@elizaos/core";
+import {
+  buildNativeAppleReminderMetadata
+} from "../lifeops/apple-reminders.js";
+import {
+  resolveDefaultTimeZone,
+  resolveDefaultWindowPolicy
+} from "../lifeops/defaults.js";
+import {
+  detailBoolean,
+  detailNumber,
+  detailObject,
+  detailString,
+  formatOverviewForQuery,
+  messageText,
+  toActionData
+} from "../lifeops/google/format-helpers.js";
+import { LifeOpsService, LifeOpsServiceError } from "../lifeops/service.js";
+import { normalizeExplicitTimeZoneToken } from "../lifeops/time/timezone.js";
+import {
+  addDaysToLocalDate,
+  buildUtcDateFromLocalParts,
+  getZonedDateParts
+} from "../lifeops/time.js";
+import {
+  extractGoalCreatePlanWithLlm,
+  extractGoalUpdatePlanWithLlm,
+  mergeGoalMetadataWithGrounding
+} from "./lib/extract-goal-plan.js";
+import {
+  extractLifeOperationWithLlm
+} from "./lib/extract-life-operation.js";
+import {
+  extractTaskCreatePlanWithLlm
+} from "./lib/extract-task-plan.js";
+import {
+  extractUpdateFieldsWithLlm
+} from "./lib/extract-update-fields.js";
+import {
+  countTurnsSinceLatestDeferredLifeDraft,
+  deferredLifeDraftExpiryReason,
+  extractDeferredLifeDraftFollowupWithLlm,
+  latestDeferredLifeDraft
+} from "./lib/lifeops-deferred-draft.js";
+import {
+  applyOwnerPolicyConfigureEscalation,
+  applyOwnerPolicySetReminder
+} from "./lib/owner-policy-writes.js";
+const SUBACTIONS = {
+  create: {
+    description: "Create a life-item: kind=definition (habit/routine/reminder/alarm/todo) or kind=goal (long-term aspiration).",
+    descriptionCompressed: "create life-item definition(habit|routine|reminder|alarm|todo)|goal; infer cadence/title",
+    required: ["kind", "title"],
+    optional: ["intent", "details"]
+  },
+  update: {
+    description: "Update an existing life-item by id or title (kind: definition or goal).",
+    descriptionCompressed: "update life-item by id/title: kind, target, fields",
+    required: ["kind", "target"],
+    optional: ["title", "details"]
+  },
+  delete: {
+    description: "Delete a life-item by id or title (kind: definition or goal).",
+    descriptionCompressed: "delete life-item by id/title",
+    required: ["kind", "target"]
+  },
+  complete: {
+    description: "Mark an occurrence as done.",
+    descriptionCompressed: "mark occurrence done",
+    required: ["target"]
+  },
+  skip: {
+    description: "Skip an occurrence.",
+    descriptionCompressed: "skip occurrence",
+    required: ["target"]
+  },
+  snooze: {
+    description: "Snooze an occurrence by minutes or preset duration.",
+    descriptionCompressed: "snooze occurrence; duration",
+    required: ["target"],
+    optional: ["minutes"]
+  },
+  review: {
+    description: "Review progress on a goal.",
+    descriptionCompressed: "review goal progress",
+    required: ["target"]
+  },
+  policy_set_reminder: {
+    description: "Set reminder intensity policy on the OwnerFactStore: minimal | normal | persistent | high_priority_only. Optional per-definition target.",
+    descriptionCompressed: "policy.set_reminder: intensity=minimal|normal|persistent|high_priority_only",
+    required: [],
+    optional: ["intent", "details"]
+  },
+  policy_configure_escalation: {
+    description: "Configure escalation policy on the OwnerFactStore (timeoutMinutes, callAfterMinutes). Optional per-definition target.",
+    descriptionCompressed: "policy.configure_escalation: timeout-minutes call-after-no-response",
+    required: [],
+    optional: ["intent", "details"]
+  }
+};
+function toInternalLifeOp(operation, kind) {
+  switch (operation) {
+    case "create":
+      return kind === "goal" ? "create_goal" : "create_definition";
+    case "update":
+      return kind === "goal" ? "update_goal" : "update_definition";
+    case "delete":
+      return kind === "goal" ? "delete_goal" : "delete_definition";
+    case "complete":
+      return "complete_occurrence";
+    case "skip":
+      return "skip_occurrence";
+    case "snooze":
+      return "snooze_occurrence";
+    case "review":
+      return "review_goal";
+    case "policy_set_reminder":
+      return "policy_set_reminder";
+    case "policy_configure_escalation":
+      return "policy_configure_escalation";
+  }
+}
+function inferLifeKindFromIntent(intent) {
+  const normalized = intent.toLowerCase();
+  if (/\bgoal\b|\baspirat|achiev|long[\s-]?term/.test(normalized) || /\bi (?:want|hope|wish|aspire) to\b/.test(normalized)) {
+    return "goal";
+  }
+  return "definition";
+}
+const GENERIC_DERIVED_TITLE_RE = /^(?:new\s+)?(?:habit|routine|task|goal|life goal|thing|item|something|anything|stuff|plan|reminder|todo|to do|achieve|achieve a|achieve an)$/i;
+function normalizeLifeTimeZoneToken(value) {
+  return normalizeExplicitTimeZoneToken(value);
+}
+function isLifeOwnedOperation(value) {
+  return value != null && value !== "query_calendar_today" && value !== "query_calendar_next" && value !== "query_email" && value !== "query_overview";
+}
+function normalizeExplicitLifeAction(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim().toLowerCase().replace(/[-\s]+/g, "_");
+  switch (normalized) {
+    case "create_goal":
+    case "goal_create":
+      return { operation: "create", kind: "goal" };
+    case "create_definition":
+    case "create_habit":
+    case "create_routine":
+    case "create_reminder":
+    case "create_todo":
+      return { operation: "create", kind: "definition" };
+    case "calendar":
+    case "query_calendar":
+    case "query_calendar_today":
+      return { operation: "query_calendar_today" };
+    case "query_calendar_next":
+    case "next_calendar":
+      return { operation: "query_calendar_next" };
+    case "email":
+    case "gmail":
+    case "query_email":
+      return { operation: "query_email" };
+    case "overview":
+    case "query_overview":
+      return { operation: "query_overview" };
+    case "phone":
+    case "capture_phone":
+      return "phone";
+    default:
+      return isLifeOwnedOperation(normalized) ? { operation: normalized } : null;
+  }
+}
+async function resolveLifeOperationPlan(args) {
+  const { runtime, message, state, intent, explicitOperation } = args;
+  if (explicitOperation) {
+    return {
+      operation: explicitOperation,
+      confidence: 1,
+      missing: [],
+      shouldAct: true
+    };
+  }
+  const extracted = await extractLifeOperationWithLlm({
+    runtime,
+    message,
+    state,
+    intent
+  });
+  if (!extracted.shouldAct || !extracted.operation || !isLifeOwnedOperation(extracted.operation)) {
+    return {
+      operation: isLifeOwnedOperation(extracted.operation) ? extracted.operation : null,
+      confidence: extracted.confidence,
+      missing: extracted.missing,
+      shouldAct: false
+    };
+  }
+  return {
+    operation: extracted.operation,
+    confidence: extracted.confidence,
+    missing: extracted.missing,
+    shouldAct: true
+  };
+}
+async function routeLifeSubaction(args) {
+  const { runtime, message, state, options, intent, explicitSubaction } = args;
+  if (explicitSubaction && !isLifeOwnedOperation(explicitSubaction)) {
+    return {
+      operation: explicitSubaction,
+      confidence: 1,
+      missing: [],
+      shouldAct: true
+    };
+  }
+  const resolved = await resolveActionArgs({
+    runtime,
+    message,
+    state,
+    options,
+    actionName: ownerSurfaceActionNameFromOptions(options),
+    subactions: SUBACTIONS,
+    intentHint: intent
+  });
+  if (resolved.ok) {
+    return {
+      operation: resolved.subaction,
+      confidence: 1,
+      missing: [],
+      shouldAct: true
+    };
+  }
+  return resolveLifeOperationPlan({
+    runtime,
+    message,
+    state,
+    intent,
+    explicitOperation: explicitSubaction
+  });
+}
+function resolveDeferredLifeDraftReuseMode(args) {
+  if (!args.draft) {
+    return null;
+  }
+  if (deferredLifeDraftExpiryReason(args)) {
+    return null;
+  }
+  if (detailBoolean(args.details, "confirmed") === true) {
+    return "confirm";
+  }
+  const explicitOperation = args.explicitOperation ? String(args.explicitOperation) : void 0;
+  const draftOperation = String(args.draft.operation);
+  if (explicitOperation && explicitOperation !== draftOperation) {
+    return null;
+  }
+  if (args.llmMode === "confirm" || args.llmMode === "edit") {
+    return args.llmMode;
+  }
+  return null;
+}
+function shouldForceLifeCreateExecution(args) {
+  if (args.operation !== "create" || args.kind === "goal") {
+    return false;
+  }
+  const blockingFields = args.missing.filter(
+    (field) => field !== "title" && field !== "schedule"
+  );
+  if (blockingFields.length > 0) {
+    return false;
+  }
+  if (typeof args.title === "string" && args.title.trim().length > 0) {
+    return true;
+  }
+  if (normalizeCadenceDetail(detailObject(args.details, "cadence"))) {
+    return true;
+  }
+  return false;
+}
+function requestedOwnership(domain) {
+  if (domain === "agent_ops") {
+    return { domain: "agent_ops", subjectType: "agent" };
+  }
+  return { domain: "user_lifeops", subjectType: "owner" };
+}
+function normalizeIntentText(value) {
+  return normalizeLifeInputText(value).toLowerCase();
+}
+function normalizeLifeInputText(value) {
+  return value.replace(/[\u00a0\u1680\u2000-\u200b\u202f\u205f\u3000]/g, " ").replace(/\s+/g, " ").trim();
+}
+function normalizeTitle(value) {
+  return normalizeIntentText(value);
+}
+function matchByTitle(entries, targetTitle) {
+  const normalized = normalizeTitle(targetTitle);
+  return entries.find(
+    (e) => normalizeTitle(e.definition?.title ?? e.goal?.title ?? "") === normalized
+  ) ?? entries.find(
+    (e) => normalizeTitle(e.definition?.title ?? e.goal?.title ?? "").includes(
+      normalized
+    )
+  ) ?? null;
+}
+async function resolveGoal(service, target, domain) {
+  if (!target) return null;
+  const goals = (await service.listGoals()).filter(
+    (e) => domain ? e.goal.domain === domain : true
+  );
+  return goals.find((e) => e.goal.id === target) ?? matchByTitle(goals, target);
+}
+async function resolveDefinition(service, target, domain) {
+  if (!target) return null;
+  const defs = (await service.listDefinitions()).filter(
+    (e) => domain ? e.definition.domain === domain : true
+  );
+  return defs.find((e) => e.definition.id === target) ?? matchByTitle(defs, target);
+}
+function tokenizeTitle(value) {
+  return normalizeTitle(value).split(" ").filter((token) => token.length >= 3);
+}
+async function resolveDefinitionFromIntent(service, target, intent, domain) {
+  const direct = await resolveDefinition(service, target, domain);
+  if (direct) {
+    return direct;
+  }
+  const defs = (await service.listDefinitions()).filter(
+    (entry) => domain ? entry.definition.domain === domain : true
+  );
+  const intentTokens = new Set(tokenizeTitle(intent));
+  let best = null;
+  let bestScore = 0;
+  let tied = false;
+  for (const entry of defs) {
+    const title = normalizeTitle(entry.definition.title);
+    if (title.length > 0 && normalizeTitle(intent).includes(title)) {
+      return entry;
+    }
+    const overlap = tokenizeTitle(entry.definition.title).filter(
+      (token) => intentTokens.has(token)
+    ).length;
+    if (overlap === 0) {
+      continue;
+    }
+    if (overlap > bestScore) {
+      best = entry;
+      bestScore = overlap;
+      tied = false;
+      continue;
+    }
+    if (overlap === bestScore) {
+      tied = true;
+    }
+  }
+  return bestScore > 0 && !tied ? best : null;
+}
+function formatOccurrenceDisambiguationLabel(occurrence) {
+  const hints = [];
+  if (typeof occurrence.windowName === "string" && occurrence.windowName.trim()) {
+    hints.push(occurrence.windowName.trim());
+  }
+  if (occurrence.dueAt) {
+    const dueAt = new Date(occurrence.dueAt);
+    if (!Number.isNaN(dueAt.getTime())) {
+      hints.push(
+        dueAt.toLocaleString(void 0, {
+          month: "short",
+          day: "numeric",
+          hour: "numeric",
+          minute: "2-digit"
+        })
+      );
+    }
+  }
+  return hints.length > 0 ? `${occurrence.title} (${hints.join(", ")})` : occurrence.title;
+}
+function narrowOccurrenceCandidates(matches) {
+  const actionableMatches = matches.filter(
+    (occurrence) => occurrence.state === "visible" || occurrence.state === "snoozed"
+  );
+  return actionableMatches.length > 0 ? actionableMatches : matches;
+}
+async function resolveOccurrence(service, target, domain) {
+  if (!target) return { match: null, ambiguousCandidates: [] };
+  const overview = await service.getOverview();
+  const all = [
+    ...overview.owner.occurrences,
+    ...overview.agentOps.occurrences
+  ].filter((o) => domain ? o.domain === domain : true);
+  const normalized = normalizeTitle(target);
+  const byId = all.find((o) => o.id === target);
+  if (byId) return { match: byId, ambiguousCandidates: [] };
+  const exactMatches = all.filter(
+    (o) => normalizeTitle(o.title) === normalized
+  );
+  if (exactMatches.length === 1) {
+    return { match: exactMatches.at(0) ?? null, ambiguousCandidates: [] };
+  }
+  if (exactMatches.length > 1) {
+    const narrowedMatches = narrowOccurrenceCandidates(exactMatches);
+    if (narrowedMatches.length === 1) {
+      return { match: narrowedMatches.at(0) ?? null, ambiguousCandidates: [] };
+    }
+    return {
+      match: null,
+      ambiguousCandidates: narrowedMatches.map(
+        formatOccurrenceDisambiguationLabel
+      )
+    };
+  }
+  const substringMatches = all.filter(
+    (o) => normalizeTitle(o.title).includes(normalized)
+  );
+  if (substringMatches.length === 1) {
+    return { match: substringMatches.at(0) ?? null, ambiguousCandidates: [] };
+  }
+  if (substringMatches.length > 1) {
+    const narrowedSubstringMatches = narrowOccurrenceCandidates(substringMatches);
+    if (narrowedSubstringMatches.length === 1) {
+      return {
+        match: narrowedSubstringMatches.at(0) ?? null,
+        ambiguousCandidates: []
+      };
+    }
+    const startsWithMatches = narrowedSubstringMatches.filter(
+      (o) => normalizeTitle(o.title).startsWith(normalized)
+    );
+    if (startsWithMatches.length === 1) {
+      return {
+        match: startsWithMatches.at(0) ?? null,
+        ambiguousCandidates: []
+      };
+    }
+    if (startsWithMatches.length > 1) {
+      return {
+        match: null,
+        ambiguousCandidates: startsWithMatches.map(
+          formatOccurrenceDisambiguationLabel
+        )
+      };
+    }
+    return {
+      match: null,
+      ambiguousCandidates: narrowedSubstringMatches.map(
+        formatOccurrenceDisambiguationLabel
+      )
+    };
+  }
+  const targetTokens = normalized.split(/\s+/).filter(Boolean);
+  if (targetTokens.length > 1) {
+    const tokenSetMatches = all.filter((occurrence) => {
+      const occurrenceTokens = new Set(
+        normalizeTitle(occurrence.title).split(/\s+/).filter(Boolean)
+      );
+      return targetTokens.every((token) => occurrenceTokens.has(token));
+    });
+    if (tokenSetMatches.length === 1) {
+      return { match: tokenSetMatches.at(0) ?? null, ambiguousCandidates: [] };
+    }
+    if (tokenSetMatches.length > 1) {
+      const narrowedTokenSetMatches = narrowOccurrenceCandidates(tokenSetMatches);
+      if (narrowedTokenSetMatches.length === 1) {
+        return {
+          match: narrowedTokenSetMatches.at(0) ?? null,
+          ambiguousCandidates: []
+        };
+      }
+      return {
+        match: null,
+        ambiguousCandidates: narrowedTokenSetMatches.map(
+          formatOccurrenceDisambiguationLabel
+        )
+      };
+    }
+  }
+  return { match: null, ambiguousCandidates: [] };
+}
+function deriveOccurrenceTargetFromIntent(intent, operation) {
+  const normalized = normalizeLifeInputText(intent);
+  if (!normalized) {
+    return null;
+  }
+  let candidate = normalized;
+  if (operation === "snooze") {
+    candidate = candidate.replace(
+      /^(?:please\s+)?(?:snooze|postpone|push\b.*\bback|remind me later about)\s+/i,
+      ""
+    ).replace(/\bfor\s+\d+\s*(?:minutes?|hours?)\b.*$/i, "").replace(/\b(?:until|til)\b.+$/i, "").trim();
+  } else if (operation === "skip") {
+    candidate = candidate.replace(/^(?:please\s+)?(?:skip|pass on)\s+/i, "").replace(/\b(?:today|tonight|for now)\b.*$/i, "").trim();
+  } else if (operation === "complete") {
+    candidate = candidate.replace(
+      /^(?:please\s+)?(?:mark\s+|i(?:'ve| have)?\s+|just\s+)?(?:done|completed|finished|did)\s+/i,
+      ""
+    ).replace(/\b(?:done|complete|completed|finished)\b.*$/i, "").trim();
+  }
+  return candidate.length > 0 ? candidate : null;
+}
+async function resolveOccurrenceWithIntentFallback(args) {
+  const direct = await resolveOccurrence(
+    args.service,
+    args.target,
+    args.domain
+  );
+  if (direct.match || direct.ambiguousCandidates.length > 0) {
+    return direct;
+  }
+  const fallbackTarget = deriveOccurrenceTargetFromIntent(
+    args.intent,
+    args.operation
+  );
+  if (!fallbackTarget || args.target && normalizeTitle(fallbackTarget) === normalizeTitle(args.target)) {
+    return direct;
+  }
+  return resolveOccurrence(args.service, fallbackTarget, args.domain);
+}
+function summarizeCadence(cadence) {
+  const cadenceWindows = Array.isArray(
+    cadence.windows
+  ) ? (cadence.windows ?? []).filter(
+    (windowName) => typeof windowName === "string" && windowName.trim().length > 0
+  ) : [];
+  switch (cadence.kind) {
+    case "once": {
+      const dueAt = new Date(cadence.dueAt);
+      if (Number.isNaN(dueAt.getTime())) {
+        return "once";
+      }
+      return `once on ${dueAt.toLocaleString(void 0, {
+        month: "short",
+        day: "numeric",
+        hour: "numeric",
+        minute: "2-digit",
+        timeZone: resolveDefaultTimeZone()
+      })}`;
+    }
+    case "daily":
+      return cadenceWindows.length > 0 ? `every day in ${cadenceWindows.join(", ")}` : "every day";
+    case "times_per_day":
+      return cadence.slots.map((slot) => slot.label.trim() || `${slot.minuteOfDay}`).filter(Boolean).join(" and ");
+    case "interval":
+      return cadenceWindows.length > 0 ? `every ${cadence.everyMinutes} minutes in ${cadenceWindows.join(", ")}` : `every ${cadence.everyMinutes} minutes`;
+    case "weekly":
+      return `weekly on ${cadence.weekdays.map(
+        (weekday) => [
+          "Sunday",
+          "Monday",
+          "Tuesday",
+          "Wednesday",
+          "Thursday",
+          "Friday",
+          "Saturday"
+        ][weekday] ?? String(weekday)
+      ).join(", ")}`;
+  }
+}
+function buildRuleBasedLifeReply(args) {
+  const context = args.context ?? {};
+  const updated = context.updated && typeof context.updated === "object" ? context.updated : null;
+  const created = context.created && typeof context.created === "object" ? context.created : null;
+  const title = (typeof updated?.title === "string" ? updated.title : null) ?? (typeof created?.title === "string" ? created.title : null) ?? (typeof context.title === "string" ? context.title : null) ?? null;
+  switch (args.scenario) {
+    case "updated_definition":
+      if (title) {
+        return `${title} is updated.`;
+      }
+      break;
+    case "deleted_definition":
+      if (title) {
+        return `${title} is off your list.`;
+      }
+      break;
+    case "deleted_goal":
+      if (title) {
+        return `${title} is off your goals list.`;
+      }
+      break;
+    case "completed_occurrence":
+      if (title) {
+        return `Marked ${title} done.`;
+      }
+      break;
+    case "skipped_occurrence":
+      if (title) {
+        return `Okay, skipping ${title} for now.`;
+      }
+      break;
+    case "snoozed_occurrence":
+      if (title) {
+        return `Okay, I'll bring ${title} back a bit later.`;
+      }
+      break;
+    default:
+      break;
+  }
+  return args.fallback;
+}
+async function renderLifeActionReply(args) {
+  const { runtime, message, state, intent, scenario, fallback, context } = args;
+  const naturalFallback = buildRuleBasedLifeReply({
+    scenario,
+    intent,
+    fallback,
+    context
+  });
+  return renderGroundedActionReply({
+    runtime,
+    message,
+    state,
+    intent,
+    domain: "lifeops",
+    scenario,
+    fallback: naturalFallback,
+    context,
+    preferCharacterVoice: true,
+    additionalRules: [
+      "Mirror the user's phrasing for time and date when possible.",
+      "Prefer phrases like tomorrow morning, every night, 7 am, or the user's own wording over robotic schedule language.",
+      "Never surface raw ISO timestamps unless the user used raw ISO timestamps.",
+      "If this is a preview, make clear it is not saved yet and the user can confirm or change it naturally.",
+      "If this is reply-only, do not pretend you saved or changed anything."
+    ]
+  });
+}
+function buildLifeClarificationFallback(args) {
+  const missing = new Set(args.missing);
+  if (args.operation === "create" && args.kind === "goal") {
+    return "What do you want the goal to be?";
+  }
+  if (missing.has("title") && missing.has("schedule")) {
+    return "What do you want the todo to be, and when should it happen?";
+  }
+  if (missing.has("title")) {
+    return "What do you want it to be?";
+  }
+  if (missing.has("schedule")) {
+    return "When should it happen?";
+  }
+  return "Tell me a bit more about what you want to set up.";
+}
+function buildLifeServiceErrorFallback(error, intent) {
+  const normalized = error.message.toLowerCase();
+  if (normalized.includes("utc 'z' suffix") || normalized.includes("local datetime without 'z'") || normalized.includes("time didn't parse") || normalized.includes("invalid dueat") || normalized.includes("cadence.dueat")) {
+    return `I couldn't pin down the reminder time from "${intent}". Tell me the time again in plain language, like "Friday at 8 pm Pacific."`;
+  }
+  if (normalized.includes("when windowpreset is not provided") || normalized.includes("startat is required")) {
+    return "I still need the time for that reminder. Tell me when it should happen.";
+  }
+  if (error.status === 429 || normalized.includes("rate limit")) {
+    return "LifeOps is rate-limited right now. Try again in a bit.";
+  }
+  return "I couldn't finish that LifeOps change yet. Tell me the task and timing again, and I'll try it a different way.";
+}
+const DEFAULT_WINDOW_SLOT_TIMES = {
+  morning: {
+    minuteOfDay: 8 * 60,
+    durationMinutes: 45,
+    label: "Morning"
+  },
+  afternoon: {
+    minuteOfDay: 13 * 60,
+    durationMinutes: 45,
+    label: "Afternoon"
+  },
+  evening: {
+    minuteOfDay: 18 * 60,
+    durationMinutes: 45,
+    label: "Evening"
+  },
+  night: {
+    minuteOfDay: 21 * 60,
+    durationMinutes: 45,
+    label: "Night"
+  }
+};
+function buildSlotsFromWindows(windows) {
+  return windows.map((window, index) => {
+    const preset = DEFAULT_WINDOW_SLOT_TIMES[window];
+    return {
+      key: windows.indexOf(window) === index ? window : `${window}-${index + 1}`,
+      label: preset.label,
+      minuteOfDay: preset.minuteOfDay,
+      durationMinutes: preset.durationMinutes
+    };
+  });
+}
+function buildDistributedDailySlots(count) {
+  const normalizedCount = Math.max(1, Math.min(6, count));
+  let minutes;
+  switch (normalizedCount) {
+    case 1:
+      minutes = [9 * 60];
+      break;
+    case 2:
+      minutes = [8 * 60, 21 * 60];
+      break;
+    case 3:
+      minutes = [8 * 60, 13 * 60, 20 * 60];
+      break;
+    case 4:
+      minutes = [8 * 60, 12 * 60, 16 * 60, 20 * 60];
+      break;
+    case 5:
+      minutes = [8 * 60, 11 * 60, 14 * 60, 17 * 60, 20 * 60];
+      break;
+    default:
+      minutes = [8 * 60, 10 * 60, 12 * 60, 14 * 60, 17 * 60, 20 * 60];
+      break;
+  }
+  return minutes.map((minuteOfDay, index) => ({
+    key: `slot-${index + 1}`,
+    label: `Time ${index + 1}`,
+    minuteOfDay,
+    durationMinutes: 45
+  }));
+}
+function inferWindowFromMinuteOfDay(minuteOfDay) {
+  if (minuteOfDay < 12 * 60) {
+    return "morning";
+  }
+  if (minuteOfDay < 17 * 60) {
+    return "afternoon";
+  }
+  if (minuteOfDay < 21 * 60) {
+    return "evening";
+  }
+  return "night";
+}
+function buildSingleDailySlot(minuteOfDay, durationMinutes = 45) {
+  return {
+    key: `time-${minuteOfDay}`,
+    label: formatMinuteOfDayLabel(minuteOfDay),
+    minuteOfDay,
+    durationMinutes
+  };
+}
+function buildCustomTimeWindowPolicy(minuteOfDay, timeZone) {
+  const basePolicy = resolveDefaultWindowPolicy(timeZone);
+  return {
+    timezone: basePolicy.timezone,
+    windows: [
+      ...basePolicy.windows,
+      {
+        name: "custom",
+        label: formatMinuteOfDayLabel(minuteOfDay),
+        startMinute: minuteOfDay,
+        endMinute: Math.min(minuteOfDay + 1, 24 * 60)
+      }
+    ]
+  };
+}
+function formatMinuteOfDayLabel(minuteOfDay) {
+  const hour24 = Math.floor(minuteOfDay / 60);
+  const minute = minuteOfDay % 60;
+  const meridiem = hour24 >= 12 ? "pm" : "am";
+  const hour12 = hour24 % 12 === 0 ? 12 : hour24 % 12;
+  return minute === 0 ? `${hour12}${meridiem}` : `${hour12}:${String(minute).padStart(2, "0")}${meridiem}`;
+}
+function parseClockToken(token) {
+  const normalized = token.trim().toLowerCase();
+  if (normalized === "noon") {
+    return 12 * 60;
+  }
+  if (normalized === "midnight") {
+    return 0;
+  }
+  const match = normalized.match(/^(\d{1,2})(?::(\d{2}))?\s*(am|pm)$/);
+  if (!match) {
+    return null;
+  }
+  const hour = Number(match[1]);
+  const minute = Number(match[2] ?? "0");
+  if (!Number.isFinite(hour) || !Number.isFinite(minute) || minute >= 60) {
+    return null;
+  }
+  if (hour < 1 || hour > 12) {
+    return null;
+  }
+  const meridiem = match[3];
+  const normalizedHour = meridiem === "am" ? hour % 12 : hour % 12 === 0 ? 12 : hour % 12 + 12;
+  return normalizedHour * 60 + minute;
+}
+function parseTimeOfDayToken(token) {
+  const normalized = normalizeLifeInputText(token).toLowerCase();
+  const hhmmMatch = normalized.match(/^(\d{1,2}):(\d{2})$/);
+  if (hhmmMatch) {
+    const hour = Number(hhmmMatch[1]);
+    const minute = Number(hhmmMatch[2]);
+    if (Number.isFinite(hour) && Number.isFinite(minute) && hour >= 0 && hour <= 23 && minute >= 0 && minute < 60) {
+      return hour * 60 + minute;
+    }
+  }
+  return parseClockToken(normalized);
+}
+function buildOneOffDueAtFromMinuteOfDay(args) {
+  const now = args.now ?? /* @__PURE__ */ new Date();
+  const timeZone = args.timeZone ?? resolveDefaultTimeZone();
+  const nowParts = getZonedDateParts(now, timeZone);
+  let localDate = {
+    year: nowParts.year,
+    month: nowParts.month,
+    day: nowParts.day
+  };
+  const buildCandidate = () => buildUtcDateFromLocalParts(timeZone, {
+    ...localDate,
+    hour: Math.floor(args.minuteOfDay / 60),
+    minute: args.minuteOfDay % 60,
+    second: 0
+  });
+  let candidate = buildCandidate();
+  if (candidate.getTime() <= now.getTime()) {
+    localDate = addDaysToLocalDate(localDate, 1);
+    candidate = buildCandidate();
+  }
+  return candidate.toISOString();
+}
+function mergeMetadataRecords(...records) {
+  const merged = Object.assign(
+    {},
+    ...records.filter(
+      (record) => record != null && Object.keys(record).length > 0
+    )
+  );
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function extractExplicitDailySlots(intent) {
+  const tokens = [
+    ...intent.matchAll(/\b(\d{1,2}(?::\d{2})?\s*(?:am|pm)|noon|midnight)\b/gi)
+  ].map((match) => match[1]).filter(
+    (token) => typeof token === "string" && token.length > 0
+  );
+  const seen = /* @__PURE__ */ new Set();
+  const slots = [];
+  for (const [index, token] of tokens.entries()) {
+    const minuteOfDay = parseClockToken(token);
+    if (minuteOfDay === null || seen.has(minuteOfDay)) {
+      continue;
+    }
+    seen.add(minuteOfDay);
+    slots.push({
+      key: `clock-${index + 1}`,
+      label: token.trim(),
+      minuteOfDay,
+      durationMinutes: 45
+    });
+  }
+  return slots.sort((left, right) => left.minuteOfDay - right.minuteOfDay);
+}
+function normalizeLifeWindows(value) {
+  const values = Array.isArray(value) ? value : value == null ? [] : [value];
+  const normalized = values.flatMap((entry) => {
+    if (typeof entry !== "string") {
+      return [];
+    }
+    const lower = normalizeLifeInputText(entry).toLowerCase();
+    if (lower === "morning") return ["morning"];
+    if (lower === "afternoon") return ["afternoon"];
+    if (lower === "evening") return ["evening"];
+    if (lower === "night") return ["night"];
+    return [];
+  });
+  return [...new Set(normalized)];
+}
+function normalizeCadenceDetail(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const record = value;
+  const cadenceKind = typeof record.kind === "string" ? normalizeLifeInputText(record.kind).toLowerCase() : typeof record.type === "string" ? normalizeLifeInputText(record.type).toLowerCase() : "";
+  if (!cadenceKind) {
+    return void 0;
+  }
+  if (cadenceKind === "once" && typeof record.dueAt === "string") {
+    return {
+      kind: "once",
+      dueAt: record.dueAt
+    };
+  }
+  if (cadenceKind === "interval") {
+    const everyMinutes = typeof record.everyMinutes === "number" ? record.everyMinutes : typeof record.everyMinutes === "string" ? Number(record.everyMinutes) : typeof record.minutes === "number" ? record.minutes : typeof record.minutes === "string" ? Number(record.minutes) : NaN;
+    if (Number.isFinite(everyMinutes) && everyMinutes > 0) {
+      return {
+        kind: "interval",
+        everyMinutes,
+        windows: normalizeLifeWindows(record.windows)
+      };
+    }
+    return void 0;
+  }
+  if (cadenceKind === "weekly") {
+    const weekdays = Array.isArray(record.weekdays) ? record.weekdays.map(
+      (entry) => typeof entry === "number" ? entry : typeof entry === "string" ? Number(entry) : NaN
+    ).filter((entry) => Number.isFinite(entry)) : [];
+    if (weekdays.length > 0) {
+      return {
+        kind: "weekly",
+        weekdays,
+        windows: normalizeLifeWindows(record.windows)
+      };
+    }
+    return void 0;
+  }
+  const explicitTimes = Array.isArray(record.times) ? record.times.map(
+    (entry) => typeof entry === "string" ? parseTimeOfDayToken(entry) : null
+  ).filter((entry) => entry !== null) : [];
+  if (explicitTimes.length > 0) {
+    return {
+      kind: "times_per_day",
+      slots: explicitTimes.map((minuteOfDay, index) => ({
+        key: `time-${index + 1}`,
+        label: formatMinuteOfDayLabel(minuteOfDay),
+        minuteOfDay,
+        durationMinutes: 45
+      })),
+      visibilityLeadMinutes: 90,
+      visibilityLagMinutes: 180
+    };
+  }
+  if (cadenceKind === "times_per_day") {
+    if (Array.isArray(record.slots)) {
+      const slots = record.slots.map((entry, index) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+          return null;
+        }
+        const slot = entry;
+        const minuteOfDay = typeof slot.minuteOfDay === "number" ? slot.minuteOfDay : typeof slot.minuteOfDay === "string" ? Number(slot.minuteOfDay) : null;
+        if (minuteOfDay === null || !Number.isFinite(minuteOfDay)) {
+          return null;
+        }
+        return {
+          key: typeof slot.key === "string" && slot.key.trim().length > 0 ? slot.key : `slot-${index + 1}`,
+          label: typeof slot.label === "string" && slot.label.trim().length > 0 ? slot.label : formatMinuteOfDayLabel(minuteOfDay),
+          minuteOfDay,
+          durationMinutes: typeof slot.durationMinutes === "number" && Number.isFinite(slot.durationMinutes) && slot.durationMinutes > 0 ? slot.durationMinutes : 45
+        };
+      }).filter((entry) => entry !== null);
+      if (slots.length > 0) {
+        return {
+          kind: "times_per_day",
+          slots,
+          visibilityLeadMinutes: typeof record.visibilityLeadMinutes === "number" ? record.visibilityLeadMinutes : 90,
+          visibilityLagMinutes: typeof record.visibilityLagMinutes === "number" ? record.visibilityLagMinutes : 180
+        };
+      }
+    }
+    const count = typeof record.count === "number" ? record.count : typeof record.count === "string" ? Number(record.count) : NaN;
+    if (Number.isFinite(count) && count > 0) {
+      return {
+        kind: "times_per_day",
+        slots: buildDistributedDailySlots(count),
+        visibilityLeadMinutes: 90,
+        visibilityLagMinutes: 180
+      };
+    }
+  }
+  if (cadenceKind === "daily") {
+    const windows = normalizeLifeWindows(record.windows ?? record.window);
+    if (windows.length > 0) {
+      return {
+        kind: "daily",
+        windows
+      };
+    }
+    return {
+      kind: "daily",
+      windows: ["morning"]
+    };
+  }
+  return void 0;
+}
+function buildCadenceFromLlmParams(params, context) {
+  const kind = params.cadenceKind;
+  if (!kind) return null;
+  const effectiveTimeZone = context?.timeZone;
+  const timeOfDayMinute = typeof params.timeOfDay === "string" ? parseTimeOfDayToken(params.timeOfDay) : null;
+  const explicitSlots = typeof context?.intent === "string" ? extractExplicitDailySlots(context.intent) : [];
+  const slotDuration = typeof params.durationMinutes === "number" && params.durationMinutes > 0 ? params.durationMinutes : 45;
+  const windows = (params.windows ?? []).filter(
+    (w) => w === "morning" || w === "afternoon" || w === "evening" || w === "night"
+  );
+  const effectiveWindows = windows.length > 0 ? windows : timeOfDayMinute !== null ? [inferWindowFromMinuteOfDay(timeOfDayMinute)] : ["morning"];
+  if (kind === "once") {
+    if (timeOfDayMinute !== null) {
+      return {
+        cadence: {
+          kind: "once",
+          dueAt: buildOneOffDueAtFromMinuteOfDay({
+            minuteOfDay: timeOfDayMinute,
+            now: context?.now,
+            timeZone: effectiveTimeZone
+          })
+        }
+      };
+    }
+    return { cadence: { kind: "once", dueAt: (/* @__PURE__ */ new Date()).toISOString() } };
+  }
+  if (kind === "daily") {
+    if (explicitSlots.length >= 2) {
+      return {
+        cadence: {
+          kind: "times_per_day",
+          slots: explicitSlots.map((slot) => ({
+            ...slot,
+            durationMinutes: slot.durationMinutes
+          })),
+          visibilityLeadMinutes: 90,
+          visibilityLagMinutes: 180
+        }
+      };
+    }
+    if (timeOfDayMinute !== null) {
+      return {
+        cadence: {
+          kind: "times_per_day",
+          slots: [buildSingleDailySlot(timeOfDayMinute, slotDuration)],
+          visibilityLeadMinutes: 90,
+          visibilityLagMinutes: 180
+        }
+      };
+    }
+    if (effectiveWindows.length >= 2) {
+      return {
+        cadence: {
+          kind: "times_per_day",
+          slots: buildSlotsFromWindows(effectiveWindows),
+          visibilityLeadMinutes: 90,
+          visibilityLagMinutes: 180
+        }
+      };
+    }
+    return { cadence: { kind: "daily", windows: effectiveWindows } };
+  }
+  if (kind === "weekly") {
+    const weekdays = params.weekdays;
+    if (!weekdays || weekdays.length === 0) return null;
+    if (timeOfDayMinute !== null) {
+      return {
+        cadence: { kind: "weekly", weekdays, windows: ["custom"] },
+        windowPolicy: buildCustomTimeWindowPolicy(
+          timeOfDayMinute,
+          effectiveTimeZone ?? resolveDefaultTimeZone()
+        )
+      };
+    }
+    return { cadence: { kind: "weekly", weekdays, windows: effectiveWindows } };
+  }
+  if (kind === "interval") {
+    const everyMinutes = params.everyMinutes;
+    if (!everyMinutes || everyMinutes <= 0) return null;
+    return {
+      cadence: {
+        kind: "interval",
+        everyMinutes,
+        windows: effectiveWindows,
+        startMinuteOfDay: timeOfDayMinute ?? void 0,
+        durationMinutes: typeof params.durationMinutes === "number" && params.durationMinutes > 0 ? params.durationMinutes : void 0
+      }
+    };
+  }
+  if (kind === "times_per_day") {
+    if (explicitSlots.length >= 2) {
+      return {
+        cadence: {
+          kind: "times_per_day",
+          slots: explicitSlots.map((slot) => ({
+            ...slot,
+            durationMinutes: slot.durationMinutes
+          })),
+          visibilityLeadMinutes: 90,
+          visibilityLagMinutes: 180
+        }
+      };
+    }
+    if (timeOfDayMinute !== null) {
+      return {
+        cadence: {
+          kind: "times_per_day",
+          slots: [buildSingleDailySlot(timeOfDayMinute, slotDuration)],
+          visibilityLeadMinutes: 90,
+          visibilityLagMinutes: 180
+        }
+      };
+    }
+    const count = params.timesPerDay;
+    if (!count || count <= 0) return null;
+    return {
+      cadence: {
+        kind: "times_per_day",
+        slots: buildDistributedDailySlots(count).map((slot) => ({
+          ...slot,
+          durationMinutes: slotDuration
+        })),
+        visibilityLeadMinutes: 90,
+        visibilityLagMinutes: 180
+      }
+    };
+  }
+  return null;
+}
+function buildCadenceFromUpdateFields(args) {
+  const { currentCadence, currentWindowPolicy, timeZone, update } = args;
+  const kind = update.cadenceKind ?? currentCadence.kind;
+  const requestedWindows = normalizeLifeWindows(update.windows ?? []);
+  const timeOfDayMinute = typeof update.timeOfDay === "string" ? parseTimeOfDayToken(update.timeOfDay) : null;
+  if (kind === "interval") {
+    const everyMinutes = update.everyMinutes ?? (currentCadence.kind === "interval" ? currentCadence.everyMinutes : null);
+    if (!everyMinutes || everyMinutes <= 0) {
+      return null;
+    }
+    const windows = requestedWindows.length > 0 ? requestedWindows : currentCadence.kind === "interval" && currentCadence.windows.length > 0 ? normalizeLifeWindows(currentCadence.windows) : timeOfDayMinute !== null ? [inferWindowFromMinuteOfDay(timeOfDayMinute)] : ["morning"];
+    return {
+      cadence: {
+        kind: "interval",
+        everyMinutes,
+        windows,
+        startMinuteOfDay: timeOfDayMinute ?? (currentCadence.kind === "interval" ? currentCadence.startMinuteOfDay : void 0),
+        maxOccurrencesPerDay: currentCadence.kind === "interval" ? currentCadence.maxOccurrencesPerDay : void 0,
+        durationMinutes: currentCadence.kind === "interval" ? currentCadence.durationMinutes : void 0,
+        visibilityLeadMinutes: currentCadence.kind === "interval" ? currentCadence.visibilityLeadMinutes : void 0,
+        visibilityLagMinutes: currentCadence.kind === "interval" ? currentCadence.visibilityLagMinutes : void 0
+      }
+    };
+  }
+  if (kind === "weekly") {
+    const weekdays = update.weekdays ?? (currentCadence.kind === "weekly" ? currentCadence.weekdays : null);
+    if (!weekdays || weekdays.length === 0) {
+      return null;
+    }
+    if (timeOfDayMinute !== null) {
+      return {
+        cadence: {
+          kind: "weekly",
+          weekdays,
+          windows: ["custom"],
+          visibilityLeadMinutes: currentCadence.kind === "weekly" ? currentCadence.visibilityLeadMinutes : void 0,
+          visibilityLagMinutes: currentCadence.kind === "weekly" ? currentCadence.visibilityLagMinutes : void 0
+        },
+        windowPolicy: buildCustomTimeWindowPolicy(timeOfDayMinute, timeZone)
+      };
+    }
+    return {
+      cadence: {
+        kind: "weekly",
+        weekdays,
+        windows: requestedWindows.length > 0 ? requestedWindows : currentCadence.kind === "weekly" && currentCadence.windows.length > 0 ? currentCadence.windows : ["morning"],
+        visibilityLeadMinutes: currentCadence.kind === "weekly" ? currentCadence.visibilityLeadMinutes : void 0,
+        visibilityLagMinutes: currentCadence.kind === "weekly" ? currentCadence.visibilityLagMinutes : void 0
+      },
+      windowPolicy: currentWindowPolicy.windows.some(
+        (window) => (requestedWindows.length > 0 ? requestedWindows : ["morning"]).includes(
+          window.name
+        )
+      ) ? void 0 : resolveDefaultWindowPolicy(timeZone)
+    };
+  }
+  if (kind === "daily") {
+    if (timeOfDayMinute !== null) {
+      return {
+        cadence: {
+          kind: "times_per_day",
+          slots: [buildSingleDailySlot(timeOfDayMinute)],
+          visibilityLeadMinutes: 90,
+          visibilityLagMinutes: 180
+        }
+      };
+    }
+    return {
+      cadence: {
+        kind: "daily",
+        windows: requestedWindows.length > 0 ? requestedWindows : currentCadence.kind === "daily" && currentCadence.windows.length > 0 ? currentCadence.windows : ["morning"],
+        visibilityLeadMinutes: currentCadence.kind === "daily" ? currentCadence.visibilityLeadMinutes : void 0,
+        visibilityLagMinutes: currentCadence.kind === "daily" ? currentCadence.visibilityLagMinutes : void 0
+      }
+    };
+  }
+  if (kind === "times_per_day") {
+    if (timeOfDayMinute !== null) {
+      return {
+        cadence: {
+          kind: "times_per_day",
+          slots: [buildSingleDailySlot(timeOfDayMinute)],
+          visibilityLeadMinutes: 90,
+          visibilityLagMinutes: 180
+        }
+      };
+    }
+    if (requestedWindows.length > 0) {
+      return {
+        cadence: {
+          kind: "times_per_day",
+          slots: buildSlotsFromWindows(requestedWindows),
+          visibilityLeadMinutes: 90,
+          visibilityLagMinutes: 180
+        }
+      };
+    }
+    return currentCadence.kind === "times_per_day" ? { cadence: currentCadence } : null;
+  }
+  return currentCadence.kind === "once" ? { cadence: currentCadence } : null;
+}
+function hasDefinitionUpdateChanges(request) {
+  return request.title != null || request.cadence != null || request.priority != null || request.description != null || request.windowPolicy != null || request.reminderPlan != null;
+}
+function buildDefaultReminderPlan(label) {
+  return {
+    steps: [{ channel: "in_app", offsetMinutes: 0, label }]
+  };
+}
+function scoreDefinitionTitleQuality(value) {
+  const normalized = normalizeTitle(value ?? "");
+  if (!normalized) {
+    return Number.NEGATIVE_INFINITY;
+  }
+  let score = normalized.split(/\s+/).filter(Boolean).length;
+  if (/\b\d+\b/.test(normalized)) {
+    score += 6;
+  }
+  if (/[+&]/.test(value ?? "") || /\band\b/.test(normalized)) {
+    score += 4;
+  }
+  if (/^(?:do|work out|workout|habit|routine|task|todo|reminder|alarm)\b/.test(
+    normalized
+  )) {
+    score -= 5;
+  }
+  if (GENERIC_DERIVED_TITLE_RE.test(normalized)) {
+    score -= 6;
+  }
+  return score;
+}
+function shouldAdoptPlannerTitle(args) {
+  const plannerTitle = args.plannerTitle?.trim();
+  if (!plannerTitle) {
+    return false;
+  }
+  const currentTitle = args.currentTitle?.trim();
+  if (!currentTitle) {
+    return true;
+  }
+  if (normalizeTitle(currentTitle) === normalizeTitle(plannerTitle)) {
+    return false;
+  }
+  return scoreDefinitionTitleQuality(plannerTitle) > scoreDefinitionTitleQuality(currentTitle);
+}
+function shouldAdoptPlannerCadence(args) {
+  const { currentCadence, plannerCadence } = args;
+  if (!currentCadence) {
+    return true;
+  }
+  if (currentCadence.kind === "times_per_day") {
+    return plannerCadence.kind === "times_per_day" && plannerCadence.slots.length >= currentCadence.slots.length || plannerCadence.kind === "once" && currentCadence.slots.length === 1;
+  }
+  if (currentCadence.kind === "weekly") {
+    return plannerCadence.kind === "weekly" && plannerCadence.weekdays.length >= currentCadence.weekdays.length && (currentCadence.windows.includes("custom") ? plannerCadence.windows.includes("custom") : plannerCadence.windows.length >= currentCadence.windows.length);
+  }
+  if (currentCadence.kind === "interval") {
+    return plannerCadence.kind === "interval";
+  }
+  if (currentCadence.kind === "once") {
+    return plannerCadence.kind === "once";
+  }
+  if (currentCadence.kind === "daily") {
+    return plannerCadence.kind === "times_per_day" || plannerCadence.kind === "daily" && plannerCadence.windows.length >= currentCadence.windows.length;
+  }
+  return true;
+}
+function shouldRequireLifeCreateConfirmation(args) {
+  if (args.messageSource === "autonomy") {
+    return false;
+  }
+  if (args.requestKind && args.cadence?.kind === "once") {
+    return false;
+  }
+  return !args.confirmed;
+}
+function formatGoalExperienceLoopSummary(experienceLoop) {
+  if (!experienceLoop?.summary) {
+    return null;
+  }
+  const similarGoalTitle = experienceLoop.similarGoals?.[0]?.title?.trim();
+  const carryForwardTitle = experienceLoop.suggestedCarryForward?.[0]?.title?.trim();
+  const parts = [experienceLoop.summary.trim()];
+  if (similarGoalTitle) {
+    parts.push(`Closest match: "${similarGoalTitle}".`);
+  }
+  if (carryForwardTitle) {
+    parts.push(`Carry forward "${carryForwardTitle}" if it still fits.`);
+  }
+  return parts.join(" ");
+}
+function formatWeeklyGoalReview(args) {
+  const parts = [
+    `Weekly goal review: ${args.summary.totalGoals} active ${args.summary.totalGoals === 1 ? "goal" : "goals"}, ${args.summary.onTrackCount} on track, ${args.summary.atRiskCount} at risk, ${args.summary.needsAttentionCount} needing attention.`
+  ];
+  if (args.atRisk.length > 0) {
+    parts.push(
+      `Drifting: ${args.atRisk.slice(0, 3).map((review) => review.goal.title).join(", ")}.`
+    );
+  }
+  if (args.needsAttention.length > 0) {
+    parts.push(
+      `Needs attention: ${args.needsAttention.slice(0, 3).map((review) => review.goal.title).join(", ")}.`
+    );
+  }
+  if (args.onTrack.length > 0) {
+    parts.push(
+      `On track: ${args.onTrack.slice(0, 3).map((review) => review.goal.title).join(", ")}.`
+    );
+  }
+  return parts.join(" ");
+}
+async function isForeignPageScope(runtime, message) {
+  const room = await runtime.getRoom(message.roomId);
+  const metadata = extractConversationMetadataFromRoom(room);
+  return isPageScopedConversationMetadata(metadata);
+}
+const OWNER_OPERATION_TAGS = [
+  "domain:reminders",
+  "capability:read",
+  "capability:write",
+  "capability:update",
+  "capability:delete",
+  "capability:schedule",
+  "surface:internal"
+];
+const OWNER_OPERATION_CONTEXTS = [
+  "general",
+  "tasks",
+  "todos",
+  "calendar",
+  "health"
+];
+const OWNER_OPERATION_ROLE_GATE = { minRole: "OWNER" };
+const OWNER_OPERATION_SUPPRESS_POST_ACTION_CONTINUATION = true;
+const OWNER_OPERATION_VALIDATE = async (runtime, message) => {
+  if (await isForeignPageScope(runtime, message)) {
+    return false;
+  }
+  return true;
+};
+function ownerSurfaceActionNameFromOptions(options) {
+  const raw = options?.parameters;
+  return typeof raw?.ownerSurface === "string" && raw.ownerSurface.length > 0 ? raw.ownerSurface : "OWNER_TODOS";
+}
+async function runLifeOperationHandler(runtime, message, state, options, _callback) {
+  const ownerSurfaceActionName = ownerSurfaceActionNameFromOptions(options);
+  if (await isForeignPageScope(runtime, message)) {
+    return {
+      success: false,
+      text: "",
+      data: {
+        actionName: ownerSurfaceActionName,
+        reason: "foreign_page_scope"
+      }
+    };
+  }
+  const rawParams = options?.parameters;
+  const params = rawParams ?? {};
+  const currentText = normalizeLifeInputText(messageText(message));
+  const details = params.details;
+  const deferredDraft = latestDeferredLifeDraft(state);
+  const turnsSinceDraft = deferredDraft != null ? (countTurnsSinceLatestDeferredLifeDraft(state) ?? 0) + 1 : void 0;
+  const deferredDraftFollowupMode = deferredDraft ? await extractDeferredLifeDraftFollowupWithLlm({
+    runtime,
+    message,
+    state,
+    currentText,
+    draft: deferredDraft
+  }) : null;
+  const draftExpiryReason = deferredLifeDraftExpiryReason({
+    draft: deferredDraft,
+    turnsSinceDraft
+  });
+  if (draftExpiryReason && deferredDraftFollowupMode === "confirm") {
+    const fallback = "That LifeOps draft expired. Please restate it and I'll preview it again.";
+    return {
+      success: false,
+      text: await renderLifeActionReply({
+        runtime,
+        message,
+        state,
+        intent: currentText,
+        scenario: "reply_only",
+        fallback,
+        context: {
+          reason: "draft_expired"
+        }
+      })
+    };
+  }
+  if (deferredDraftFollowupMode === "cancel") {
+    const fallback = "Okay, I won't save it yet.";
+    return {
+      success: true,
+      text: await renderLifeActionReply({
+        runtime,
+        message,
+        state,
+        intent: currentText,
+        scenario: "reply_only",
+        fallback,
+        context: {
+          reason: "draft_cancelled",
+          draft: deferredDraft ? {
+            operation: deferredDraft.operation,
+            title: deferredDraft.request.title
+          } : null
+        }
+      }),
+      data: {
+        actionName: ownerSurfaceActionName,
+        noop: true
+      }
+    };
+  }
+  const explicitAction = normalizeExplicitLifeAction(params.action);
+  if (explicitAction === "phone") {
+    return {
+      success: false,
+      text: "I need the phone number before I can save text reminders.",
+      data: {
+        actionName: ownerSurfaceActionName,
+        missingField: "phone_number"
+      }
+    };
+  }
+  const explicitSubaction = typeof params.subaction === "string" && Object.hasOwn(SUBACTIONS, params.subaction) ? params.subaction : explicitAction?.operation;
+  const deferredDraftReuseMode = resolveDeferredLifeDraftReuseMode({
+    details,
+    draft: deferredDraft,
+    explicitOperation: explicitSubaction,
+    llmMode: deferredDraftFollowupMode,
+    turnsSinceDraft
+  });
+  const reuseDeferredDraft = deferredDraftReuseMode !== null;
+  const intent = reuseDeferredDraft ? deferredDraftReuseMode === "confirm" ? normalizeLifeInputText(deferredDraft?.intent ?? "") : normalizeLifeInputText(params.intent?.trim() ?? currentText) : normalizeLifeInputText(params.intent?.trim() ?? currentText);
+  if (!intent) {
+    const fallback = "Tell me what you want me to do.";
+    return {
+      success: false,
+      text: await renderLifeActionReply({
+        runtime,
+        message,
+        state,
+        intent: currentText,
+        scenario: "reply_only",
+        fallback,
+        context: {
+          reason: "missing_intent"
+        }
+      })
+    };
+  }
+  const operationPlan = reuseDeferredDraft && deferredDraft ? {
+    confidence: 1,
+    missing: [],
+    operation: "create",
+    kind: deferredDraft.operation === "create_goal" ? "goal" : "definition",
+    shouldAct: true
+  } : explicitAction ? {
+    confidence: 1,
+    missing: [],
+    operation: explicitAction.operation,
+    kind: explicitAction.kind,
+    shouldAct: true
+  } : await routeLifeSubaction({
+    runtime,
+    message,
+    state,
+    options,
+    intent,
+    explicitSubaction
+  });
+  const explicitKind = params.kind === "definition" || params.kind === "goal" ? params.kind : void 0;
+  const resolvedKind = operationPlan.kind ?? explicitKind;
+  const forceCreateExecution = shouldForceLifeCreateExecution({
+    intent,
+    missing: operationPlan.missing,
+    operation: operationPlan.operation,
+    kind: resolvedKind,
+    details,
+    title: params.title
+  });
+  if (!operationPlan.shouldAct && !forceCreateExecution) {
+    const fallback = buildLifeClarificationFallback({
+      missing: operationPlan.missing,
+      operation: operationPlan.operation,
+      kind: resolvedKind
+    });
+    return {
+      success: true,
+      text: await renderLifeActionReply({
+        runtime,
+        message,
+        state,
+        intent,
+        scenario: operationPlan.operation === "create" && resolvedKind === "goal" ? "clarify_create_goal" : "clarify_create_definition",
+        fallback,
+        context: {
+          missing: operationPlan.missing,
+          operation: operationPlan.operation
+        }
+      }),
+      data: {
+        actionName: ownerSurfaceActionName,
+        noop: true,
+        suggestedOperation: operationPlan.operation
+      }
+    };
+  }
+  const operation = forceCreateExecution ? "create" : isLifeOwnedOperation(operationPlan.operation) ? operationPlan.operation : null;
+  const queryOperation = forceCreateExecution ? null : !isLifeOwnedOperation(operationPlan.operation) ? operationPlan.operation : null;
+  const service = new LifeOpsService(runtime);
+  if (queryOperation === "query_calendar_today") {
+    return {
+      success: false,
+      text: "Calendar access is not available. Grant Apple Calendar access or connect Google Calendar to use calendar actions.",
+      data: {
+        actionName: ownerSurfaceActionName,
+        operation: queryOperation
+      }
+    };
+  }
+  if (queryOperation === "query_calendar_next") {
+    return {
+      success: false,
+      text: "Calendar access is not available. Grant Apple Calendar access or connect Google Calendar to use calendar actions.",
+      data: {
+        actionName: ownerSurfaceActionName,
+        operation: queryOperation
+      }
+    };
+  }
+  if (queryOperation === "query_email") {
+    return {
+      success: false,
+      text: "Gmail is not connected. Connect Google in LifeOps settings to use Gmail actions.",
+      data: {
+        actionName: ownerSurfaceActionName,
+        operation: queryOperation
+      }
+    };
+  }
+  if (queryOperation === "query_overview") {
+    const overview = await service.getOverview();
+    const userQuery = messageText(message) || intent || "overview";
+    const fallback = formatOverviewForQuery(overview, userQuery);
+    return {
+      success: true,
+      text: await renderLifeActionReply({
+        runtime,
+        message,
+        state,
+        intent: userQuery,
+        scenario: "overview",
+        fallback,
+        context: {
+          summary: overview.owner.summary,
+          occurrenceTitles: overview.owner.occurrences.slice(0, 6).map((occurrence) => occurrence.title),
+          goalTitles: overview.owner.goals.slice(0, 3).map((goal) => goal.title)
+        }
+      }),
+      data: toActionData(overview)
+    };
+  }
+  const kind = resolvedKind ?? (operation === "create" || operation === "update" || operation === "delete" ? inferLifeKindFromIntent(intent) : "definition");
+  const internalOp = operation ? toInternalLifeOp(operation, kind) : null;
+  if (!operation) {
+    const fallback = "Tell me what LifeOps action you want me to take.";
+    return {
+      success: true,
+      text: await renderLifeActionReply({
+        runtime,
+        message,
+        state,
+        intent,
+        scenario: "reply_only",
+        fallback,
+        context: {
+          reason: "missing_operation_after_extraction"
+        }
+      }),
+      data: {
+        actionName: ownerSurfaceActionName,
+        noop: true
+      }
+    };
+  }
+  const domain = detailString(details, "domain");
+  const ownership = requestedOwnership(domain);
+  const targetName = params.target ?? params.title;
+  const createConfirmed = deferredDraftReuseMode === "confirm" || detailBoolean(details, "confirmed") === true;
+  try {
+    const createDefinition = async () => {
+      const deferredDefinitionDraft = reuseDeferredDraft && deferredDraft?.operation === "create_definition" ? deferredDraft : null;
+      const editingDeferredDefinitionDraft = deferredDraftReuseMode === "edit" && deferredDefinitionDraft?.operation === "create_definition";
+      const explicitCadenceDetail = normalizeCadenceDetail(
+        detailObject(details, "cadence")
+      );
+      const hasCompleteNativeDefinitionCreatePlan = Boolean(
+        params.title && explicitCadenceDetail && detailString(details, "kind")
+      );
+      const fallbackTitle = deferredDefinitionDraft?.request.title ?? null;
+      let title = editingDeferredDefinitionDraft ? params.title ?? fallbackTitle : fallbackTitle ?? params.title ?? null;
+      const fallbackCadence = deferredDefinitionDraft?.request.cadence;
+      let cadence = editingDeferredDefinitionDraft ? explicitCadenceDetail ?? fallbackCadence ?? void 0 : fallbackCadence ?? explicitCadenceDetail ?? void 0;
+      let windowPolicy = editingDeferredDefinitionDraft ? (
+        // detailObject returns Record<string,unknown>; cast to the policy
+        // type at this validated boundary.
+        detailObject(details, "windowPolicy") ?? deferredDefinitionDraft.request.windowPolicy
+      ) : deferredDefinitionDraft?.request.windowPolicy ?? detailObject(details, "windowPolicy");
+      const explicitPriority = detailNumber(details, "priority");
+      const explicitDescription = detailString(details, "description");
+      const explicitMetadata = detailObject(details, "metadata");
+      const hadExplicitCadence = Boolean(
+        (editingDeferredDefinitionDraft ? explicitCadenceDetail ?? deferredDefinitionDraft.request.cadence : deferredDefinitionDraft?.request.cadence) ?? explicitCadenceDetail
+      );
+      const hadExplicitTitle = Boolean(
+        (editingDeferredDefinitionDraft ? params.title : deferredDefinitionDraft?.request.title) ?? params.title
+      );
+      let llmPlan = null;
+      let llmDescription;
+      let llmPriority;
+      let llmRequestKind = null;
+      if ((!deferredDefinitionDraft || editingDeferredDefinitionDraft) && !hasCompleteNativeDefinitionCreatePlan) {
+        llmPlan = await extractTaskCreatePlanWithLlm({
+          runtime,
+          intent,
+          state: state ?? void 0,
+          message
+        });
+        const shouldHonorPlannerResponse = llmPlan.mode === "respond" && Boolean(llmPlan.response) && !editingDeferredDefinitionDraft && !params.title && !explicitCadenceDetail && !detailString(details, "description") && !detailString(details, "goalId") && !detailString(details, "goalTitle") && !detailString(details, "kind");
+        if (shouldHonorPlannerResponse && llmPlan.response) {
+          return {
+            success: true,
+            text: llmPlan.response
+          };
+        }
+        if (llmPlan) {
+          llmRequestKind = llmPlan.requestKind;
+          if (!hadExplicitTitle && shouldAdoptPlannerTitle({
+            currentTitle: title,
+            plannerTitle: llmPlan.title
+          })) {
+            title = llmPlan.title;
+          }
+          if ((editingDeferredDefinitionDraft || !hadExplicitCadence) && llmPlan.cadenceKind) {
+            const llmCadenceTimeZone = normalizeLifeTimeZoneToken(
+              detailString(details, "timeZone") ?? llmPlan.timeZone ?? deferredDefinitionDraft?.request.timezone ?? windowPolicy?.timezone
+            );
+            const llmCadence = buildCadenceFromLlmParams(llmPlan, {
+              intent,
+              timeZone: llmCadenceTimeZone ?? void 0
+            });
+            if (llmCadence && shouldAdoptPlannerCadence({
+              currentCadence: cadence,
+              plannerCadence: llmCadence.cadence
+            })) {
+              cadence = llmCadence.cadence;
+              windowPolicy = llmCadence.windowPolicy ?? windowPolicy;
+            }
+          }
+          if (!explicitDescription && llmPlan.description) {
+            llmDescription = llmPlan.description;
+          }
+          if (explicitPriority === void 0 && llmPlan.priority) {
+            llmPriority = llmPlan.priority;
+          }
+        }
+      }
+      const resolvedTimeZone = normalizeLifeTimeZoneToken(
+        detailString(details, "timeZone") ?? llmPlan?.timeZone ?? deferredDefinitionDraft?.request.timezone ?? windowPolicy?.timezone
+      );
+      const timedRequestKind = llmRequestKind;
+      const nativeAppleMetadata = timedRequestKind && cadence?.kind === "once" ? buildNativeAppleReminderMetadata({
+        kind: timedRequestKind,
+        source: "llm"
+      }) : void 0;
+      const definitionMetadata = editingDeferredDefinitionDraft ? mergeMetadataRecords(
+        deferredDefinitionDraft.request.metadata,
+        mergeMetadataRecords(explicitMetadata, nativeAppleMetadata)
+      ) : deferredDefinitionDraft?.request.metadata ?? mergeMetadataRecords(explicitMetadata, nativeAppleMetadata);
+      if (!title) {
+        const fallback2 = "What should I call it?";
+        return {
+          success: false,
+          text: await renderLifeActionReply({
+            runtime,
+            message,
+            state,
+            intent,
+            scenario: "clarify_create_definition",
+            fallback: fallback2,
+            context: {
+              missing: ["title"],
+              operation: "create_definition"
+            }
+          }),
+          // Asking the owner to fill in a missing field — selection +
+          // execution were both correct, terminal state is "needs human
+          // input". Flag so the native planner chain breaks and the spy
+          // scores this as completed.
+          values: {
+            success: false,
+            error: "MISSING_DEFINITION_FIELD",
+            missingField: "title",
+            requiresConfirmation: true
+          },
+          data: {
+            actionName: ownerSurfaceActionName,
+            missingField: "title",
+            requiresConfirmation: true
+          }
+        };
+      }
+      if (!cadence) {
+        const fallback2 = "When should it happen?";
+        return {
+          success: false,
+          text: await renderLifeActionReply({
+            runtime,
+            message,
+            state,
+            intent,
+            scenario: "clarify_create_definition",
+            fallback: fallback2,
+            context: {
+              missing: ["schedule"],
+              operation: "create_definition"
+            }
+          }),
+          values: {
+            success: false,
+            error: "MISSING_DEFINITION_FIELD",
+            missingField: "schedule",
+            requiresConfirmation: true
+          },
+          data: {
+            actionName: ownerSurfaceActionName,
+            missingField: "schedule",
+            requiresConfirmation: true
+          }
+        };
+      }
+      const kind2 = (editingDeferredDefinitionDraft ? detailString(details, "kind") : deferredDefinitionDraft?.request.kind) ?? detailString(details, "kind") ?? "habit";
+      const definitionDraft = {
+        intent,
+        operation: "create_definition",
+        createdAt: editingDeferredDefinitionDraft ? Date.now() : deferredDefinitionDraft?.createdAt ?? Date.now(),
+        request: {
+          cadence,
+          description: explicitDescription ?? llmDescription ?? (editingDeferredDefinitionDraft ? deferredDefinitionDraft.request.description : void 0),
+          goalRef: detailString(details, "goalId") ?? detailString(details, "goalTitle") ?? deferredDefinitionDraft?.request.goalRef ?? void 0,
+          kind: kind2,
+          priority: explicitPriority ?? llmPriority ?? deferredDefinitionDraft?.request.priority,
+          progressionRule: detailObject(
+            details,
+            "progressionRule"
+          ) ?? deferredDefinitionDraft?.request.progressionRule,
+          reminderPlan: detailObject(details, "reminderPlan") ?? deferredDefinitionDraft?.request.reminderPlan ?? buildDefaultReminderPlan(`${title} reminder`),
+          timezone: normalizeLifeTimeZoneToken(llmPlan?.timeZone) ?? normalizeLifeTimeZoneToken(
+            resolvedTimeZone ?? deferredDefinitionDraft?.request.timezone
+          ) ?? resolvedTimeZone ?? deferredDefinitionDraft?.request.timezone,
+          title,
+          metadata: definitionMetadata,
+          windowPolicy,
+          // detailObject returns Record<string,unknown>; cast at validated boundary.
+          websiteAccess: detailObject(details, "websiteAccess") ?? deferredDefinitionDraft?.request.websiteAccess
+        }
+      };
+      if (shouldRequireLifeCreateConfirmation({
+        confirmed: createConfirmed,
+        messageSource: typeof message.content.source === "string" ? message.content.source : void 0,
+        requestKind: timedRequestKind,
+        cadence: definitionDraft.request.cadence
+      })) {
+        const fallback2 = `I can save this as a ${definitionDraft.request.kind} named "${definitionDraft.request.title}" that happens ${summarizeCadence(definitionDraft.request.cadence)}. Confirm and I'll save it, or tell me what to change.`;
+        return {
+          success: true,
+          text: await renderLifeActionReply({
+            runtime,
+            message,
+            state,
+            intent,
+            scenario: "preview_definition",
+            fallback: fallback2,
+            context: {
+              draft: definitionDraft.request,
+              requestKind: timedRequestKind
+            }
+          }),
+          data: {
+            actionName: ownerSurfaceActionName,
+            deferred: true,
+            lifeDraft: definitionDraft,
+            preview: {
+              cadence: definitionDraft.request.cadence,
+              kind: definitionDraft.request.kind,
+              title: definitionDraft.request.title
+            }
+          }
+        };
+      }
+      const resolvedGoal = definitionDraft.request.goalRef ? await resolveGoal(service, definitionDraft.request.goalRef, domain) : null;
+      const created = await service.createDefinition({
+        ownership,
+        kind: definitionDraft.request.kind,
+        title: definitionDraft.request.title,
+        description: definitionDraft.request.description,
+        originalIntent: definitionDraft.intent || definitionDraft.request.title,
+        cadence: definitionDraft.request.cadence,
+        timezone: normalizeLifeTimeZoneToken(definitionDraft.request.timezone) ?? definitionDraft.request.timezone,
+        priority: definitionDraft.request.priority,
+        windowPolicy: definitionDraft.request.windowPolicy,
+        progressionRule: definitionDraft.request.progressionRule,
+        reminderPlan: definitionDraft.request.reminderPlan,
+        metadata: definitionDraft.request.metadata,
+        websiteAccess: definitionDraft.request.websiteAccess,
+        goalId: resolvedGoal?.goal.id ?? null,
+        source: "chat"
+      });
+      const fallback = `Saved "${created.definition.title}" as ${summarizeCadence(created.definition.cadence)}.`;
+      return {
+        success: true,
+        text: await renderLifeActionReply({
+          runtime,
+          message,
+          state,
+          intent,
+          scenario: "saved_definition",
+          fallback,
+          context: {
+            created: {
+              title: created.definition.title,
+              cadence: created.definition.cadence
+            },
+            requestKind: timedRequestKind
+          }
+        }),
+        data: toActionData(created)
+      };
+    };
+    if (internalOp === "create_definition") {
+      return await createDefinition();
+    }
+    if (internalOp === "create_goal") {
+      const deferredGoalDraft = reuseDeferredDraft && deferredDraft?.operation === "create_goal" ? deferredDraft : null;
+      const editingDeferredGoalDraft = deferredDraftReuseMode === "edit" && deferredGoalDraft?.operation === "create_goal";
+      const explicitDescription = detailString(details, "description");
+      const explicitCadence = normalizeCadenceDetail(
+        detailObject(details, "cadence")
+      );
+      const explicitSuccessCriteria = detailObject(
+        details,
+        "successCriteria"
+      );
+      const explicitSupportStrategy = detailObject(
+        details,
+        "supportStrategy"
+      );
+      const explicitMetadata = detailObject(details, "metadata");
+      let title = editingDeferredGoalDraft ? params.title ?? deferredGoalDraft.request.title : deferredGoalDraft?.request.title ?? params.title ?? null;
+      let description = editingDeferredGoalDraft ? explicitDescription ?? deferredGoalDraft.request.description : deferredGoalDraft?.request.description ?? explicitDescription;
+      let cadence = editingDeferredGoalDraft ? explicitCadence ?? deferredGoalDraft.request.cadence : deferredGoalDraft?.request.cadence ?? explicitCadence;
+      let successCriteria = editingDeferredGoalDraft ? explicitSuccessCriteria ?? deferredGoalDraft.request.successCriteria : deferredGoalDraft?.request.successCriteria ?? explicitSuccessCriteria;
+      let supportStrategy = editingDeferredGoalDraft ? explicitSupportStrategy ?? deferredGoalDraft.request.supportStrategy : deferredGoalDraft?.request.supportStrategy ?? explicitSupportStrategy;
+      let goalMetadata = editingDeferredGoalDraft ? explicitMetadata ?? deferredGoalDraft.request.metadata : deferredGoalDraft?.request.metadata ?? explicitMetadata;
+      let evaluationSummary = null;
+      const hasExplicitGroundedGoal = Boolean(title) && (createConfirmed || Boolean(successCriteria) && Boolean(supportStrategy));
+      if ((!deferredGoalDraft || editingDeferredGoalDraft) && !hasExplicitGroundedGoal) {
+        const llmPlan = await extractGoalCreatePlanWithLlm({
+          runtime,
+          intent,
+          state: state ?? void 0,
+          message
+        });
+        if (!title && llmPlan.title) {
+          title = llmPlan.title;
+        }
+        if (!description && llmPlan.description) {
+          description = llmPlan.description;
+        }
+        if (!cadence && llmPlan.cadence) {
+          cadence = llmPlan.cadence;
+        }
+        if (!successCriteria && llmPlan.successCriteria) {
+          successCriteria = llmPlan.successCriteria;
+        }
+        if (!supportStrategy && llmPlan.supportStrategy) {
+          supportStrategy = llmPlan.supportStrategy;
+        }
+        evaluationSummary = llmPlan.evaluationSummary;
+        if (llmPlan.groundingState === "grounded" && llmPlan.successCriteria && title) {
+          goalMetadata = mergeGoalMetadataWithGrounding({
+            metadata: {
+              ...goalMetadata,
+              source: "chat",
+              originalIntent: intent
+            },
+            nowIso: (/* @__PURE__ */ new Date()).toISOString(),
+            plan: llmPlan
+          });
+        }
+        if (llmPlan.groundingState !== "grounded" || !title || !successCriteria || !supportStrategy) {
+          return {
+            success: true,
+            text: llmPlan.response ?? "What would count as success for that goal, and over what time window?",
+            values: {
+              success: true,
+              error: "NOOP_GOAL_UNGROUNDED",
+              noop: true,
+              suggestedOperation: "create_goal"
+            },
+            data: {
+              actionName: ownerSurfaceActionName,
+              noop: true,
+              error: "NOOP_GOAL_UNGROUNDED",
+              suggestedOperation: "create_goal"
+            }
+          };
+        }
+      }
+      if (!title)
+        return {
+          success: false,
+          text: await renderLifeActionReply({
+            runtime,
+            message,
+            state,
+            intent,
+            scenario: "clarify_create_goal",
+            fallback: "What are you trying to achieve?",
+            context: {
+              missing: ["title"],
+              operation: "create_goal"
+            }
+          })
+        };
+      const goalDraft = deferredGoalDraft ?? {
+        intent,
+        operation: "create_goal",
+        createdAt: Date.now(),
+        request: {
+          cadence,
+          description,
+          metadata: goalMetadata,
+          successCriteria,
+          supportStrategy,
+          title
+        }
+      };
+      const experienceLoop = await service.buildGoalExperienceLoop({
+        title: goalDraft.request.title,
+        description: goalDraft.request.description,
+        successCriteria: goalDraft.request.successCriteria ?? null
+      });
+      if (shouldRequireLifeCreateConfirmation({
+        confirmed: createConfirmed,
+        messageSource: typeof message.content.source === "string" ? message.content.source : void 0
+      })) {
+        const fallbackParts = [
+          evaluationSummary ? `I can save "${goalDraft.request.title}" as a goal. Success looks like this: ${evaluationSummary} Confirm and I'll save it, or tell me what to change.` : `I can save this goal as "${goalDraft.request.title}". Confirm and I'll save it, or tell me what to change.`
+        ];
+        const experienceSummary2 = formatGoalExperienceLoopSummary(experienceLoop);
+        if (experienceSummary2) {
+          fallbackParts.push(experienceSummary2);
+        }
+        return {
+          success: true,
+          text: await renderLifeActionReply({
+            runtime,
+            message,
+            state,
+            intent,
+            scenario: "preview_goal",
+            fallback: fallbackParts.join(" "),
+            context: {
+              draft: goalDraft.request,
+              groundingSummary: evaluationSummary,
+              experienceLoop
+            }
+          }),
+          data: {
+            actionName: ownerSurfaceActionName,
+            deferred: true,
+            lifeDraft: goalDraft,
+            experienceLoop,
+            preview: {
+              title: goalDraft.request.title
+            }
+          }
+        };
+      }
+      const created = await service.createGoal({
+        ownership,
+        title: goalDraft.request.title,
+        description: goalDraft.request.description,
+        cadence: goalDraft.request.cadence,
+        supportStrategy: goalDraft.request.supportStrategy,
+        successCriteria: goalDraft.request.successCriteria,
+        metadata: {
+          ...goalDraft.request.metadata,
+          source: "chat",
+          originalIntent: goalDraft.intent || goalDraft.request.title
+        }
+      });
+      const createdExperienceLoop = await service.buildGoalExperienceLoop({
+        goalId: created.goal.id,
+        title: created.goal.title,
+        description: created.goal.description,
+        successCriteria: created.goal.successCriteria ?? null
+      });
+      const experienceSummary = formatGoalExperienceLoopSummary(
+        createdExperienceLoop
+      );
+      const fallback = experienceSummary ? `Saved goal "${created.goal.title}". ${experienceSummary}` : `Saved goal "${created.goal.title}".`;
+      return {
+        success: true,
+        text: await renderLifeActionReply({
+          runtime,
+          message,
+          state,
+          intent,
+          scenario: "saved_goal",
+          fallback,
+          context: {
+            created: {
+              title: created.goal.title,
+              cadence: created.goal.cadence
+            },
+            experienceLoop: createdExperienceLoop
+          }
+        }),
+        data: toActionData({
+          ...created,
+          experienceLoop: createdExperienceLoop
+        })
+      };
+    }
+    if (internalOp === "update_definition") {
+      const target = await resolveDefinition(service, targetName, domain);
+      if (!target)
+        return {
+          success: false,
+          text: "I could not find that item to update."
+        };
+      const request = {
+        ownership,
+        title: params.title !== target.definition.title ? params.title : void 0,
+        description: detailString(details, "description"),
+        cadence: normalizeCadenceDetail(detailObject(details, "cadence")),
+        priority: detailNumber(details, "priority"),
+        // detailObject returns Record<string,unknown>; cast at validated boundary.
+        windowPolicy: detailObject(
+          details,
+          "windowPolicy"
+        ),
+        reminderPlan: detailObject(
+          details,
+          "reminderPlan"
+        )
+      };
+      const hasExplicitChanges = hasDefinitionUpdateChanges(request);
+      if (!hasExplicitChanges && intent) {
+        const llmFields = await extractUpdateFieldsWithLlm({
+          runtime,
+          intent,
+          currentTitle: target.definition.title,
+          currentCadenceKind: target.definition.cadence.kind,
+          currentWindows: target.definition.windowPolicy.windows.map(
+            (w) => w.name
+          )
+        });
+        if (llmFields) {
+          if (llmFields.title) request.title = llmFields.title;
+          if (llmFields.priority) request.priority = llmFields.priority;
+          if (llmFields.description)
+            request.description = llmFields.description;
+          if (llmFields.cadenceKind || llmFields.windows || llmFields.weekdays || llmFields.everyMinutes || llmFields.timeOfDay) {
+            const built = buildCadenceFromUpdateFields({
+              currentCadence: target.definition.cadence,
+              currentWindowPolicy: target.definition.windowPolicy,
+              timeZone: target.definition.timezone,
+              update: llmFields
+            });
+            if (built) {
+              request.cadence = built.cadence;
+              request.windowPolicy = built.windowPolicy;
+            }
+          }
+        }
+      }
+      if (!hasDefinitionUpdateChanges(request)) {
+        return {
+          success: false,
+          text: `Tell me what to change about "${target.definition.title}" and I'll update it.`
+        };
+      }
+      const updated = await service.updateDefinition(
+        target.definition.id,
+        request
+      );
+      const fallback = `Updated "${updated.definition.title}".`;
+      return {
+        success: true,
+        text: await renderLifeActionReply({
+          runtime,
+          message,
+          state,
+          intent,
+          scenario: "updated_definition",
+          fallback,
+          context: {
+            previousTitle: target.definition.title,
+            updated: {
+              title: updated.definition.title
+            }
+          }
+        }),
+        data: toActionData(updated)
+      };
+    }
+    if (internalOp === "update_goal") {
+      const target = await resolveGoal(service, targetName, domain);
+      if (!target)
+        return {
+          success: false,
+          text: "I could not find that goal to update."
+        };
+      const request = {
+        ownership,
+        title: params.title !== target.goal.title ? params.title : void 0,
+        description: detailString(details, "description"),
+        cadence: normalizeCadenceDetail(
+          detailObject(details, "cadence")
+        ),
+        supportStrategy: detailObject(details, "supportStrategy"),
+        successCriteria: detailObject(details, "successCriteria")
+      };
+      const hasExplicitGoalChanges = request.title !== void 0 || request.description !== void 0 || request.cadence !== void 0 || request.supportStrategy !== void 0 || request.successCriteria !== void 0;
+      if (!hasExplicitGoalChanges) {
+        const llmPlan = await extractGoalUpdatePlanWithLlm({
+          runtime,
+          currentGoal: target.goal,
+          intent,
+          state: state ?? void 0,
+          message
+        });
+        if (llmPlan.mode === "respond") {
+          return {
+            success: true,
+            text: llmPlan.response ?? `Tell me what to change about "${target.goal.title}" and I'll update it.`,
+            data: {
+              actionName: ownerSurfaceActionName,
+              noop: true,
+              suggestedOperation: "update_goal"
+            }
+          };
+        }
+        if (llmPlan.title) request.title = llmPlan.title;
+        if (llmPlan.description) request.description = llmPlan.description;
+        if (llmPlan.cadence) request.cadence = llmPlan.cadence;
+        if (llmPlan.supportStrategy)
+          request.supportStrategy = llmPlan.supportStrategy;
+        if (llmPlan.successCriteria)
+          request.successCriteria = llmPlan.successCriteria;
+        if (llmPlan.groundingState) {
+          request.metadata = mergeGoalMetadataWithGrounding({
+            metadata: target.goal.metadata,
+            nowIso: (/* @__PURE__ */ new Date()).toISOString(),
+            plan: {
+              cadence: llmPlan.cadence,
+              confidence: llmPlan.confidence,
+              evaluationSummary: llmPlan.evaluationSummary,
+              groundingState: llmPlan.groundingState,
+              missingCriticalFields: llmPlan.missingCriticalFields,
+              successCriteria: llmPlan.successCriteria ?? target.goal.successCriteria,
+              targetDomain: llmPlan.targetDomain
+            }
+          });
+        }
+      }
+      if (request.title === void 0 && request.description === void 0 && request.cadence === void 0 && request.supportStrategy === void 0 && request.successCriteria === void 0 && request.metadata === void 0) {
+        return {
+          success: false,
+          text: `Tell me what to change about "${target.goal.title}" and I'll update it.`
+        };
+      }
+      const updated = await service.updateGoal(target.goal.id, request);
+      const fallback = `Updated goal "${updated.goal.title}".`;
+      return {
+        success: true,
+        text: await renderLifeActionReply({
+          runtime,
+          message,
+          state,
+          intent,
+          scenario: "updated_goal",
+          fallback,
+          context: {
+            previousTitle: target.goal.title,
+            updated: {
+              title: updated.goal.title
+            }
+          }
+        }),
+        data: toActionData(updated)
+      };
+    }
+    if (internalOp === "delete_definition") {
+      const target = await resolveDefinition(service, targetName, domain);
+      if (!target)
+        return {
+          success: false,
+          text: "I could not find that item to delete."
+        };
+      await service.deleteDefinition(target.definition.id);
+      const fallback = `Deleted "${target.definition.title}" and its occurrences.`;
+      return {
+        success: true,
+        text: await renderLifeActionReply({
+          runtime,
+          message,
+          state,
+          intent,
+          scenario: "deleted_definition",
+          fallback,
+          context: {
+            deleted: {
+              title: target.definition.title
+            }
+          }
+        })
+      };
+    }
+    if (internalOp === "delete_goal") {
+      const target = await resolveGoal(service, targetName, domain);
+      if (!target)
+        return {
+          success: false,
+          text: "I could not find that goal to delete."
+        };
+      await service.deleteGoal(target.goal.id);
+      const fallback = `Deleted goal "${target.goal.title}".`;
+      return {
+        success: true,
+        text: await renderLifeActionReply({
+          runtime,
+          message,
+          state,
+          intent,
+          scenario: "deleted_goal",
+          fallback,
+          context: {
+            deleted: {
+              title: target.goal.title
+            }
+          }
+        })
+      };
+    }
+    if (internalOp === "complete_occurrence") {
+      const directOccurrenceId = detailString(details, "occurrenceId");
+      let resolvedTargetId;
+      if (directOccurrenceId) {
+        resolvedTargetId = directOccurrenceId;
+      } else {
+        const { match: target, ambiguousCandidates } = await resolveOccurrenceWithIntentFallback({
+          service,
+          target: targetName,
+          domain,
+          intent,
+          operation
+        });
+        if (!target) {
+          if (ambiguousCandidates.length > 0) {
+            return {
+              success: false,
+              text: `Multiple items match \u2014 which one?
+${ambiguousCandidates.map((t) => `  - ${t}`).join("\n")}`
+            };
+          }
+          return {
+            success: false,
+            text: "I could not find that active item to complete."
+          };
+        }
+        resolvedTargetId = target.id;
+      }
+      const completed = await service.completeOccurrence(resolvedTargetId, {
+        note: detailString(details, "note")
+      });
+      const fallback = `Marked "${completed.title}" done.`;
+      return {
+        success: true,
+        text: await renderLifeActionReply({
+          runtime,
+          message,
+          state,
+          intent,
+          scenario: "completed_occurrence",
+          fallback,
+          context: {
+            completed: {
+              title: completed.title
+            },
+            note: detailString(details, "note")
+          }
+        }),
+        data: toActionData(completed)
+      };
+    }
+    if (internalOp === "skip_occurrence") {
+      const { match: target, ambiguousCandidates } = await resolveOccurrenceWithIntentFallback({
+        service,
+        target: targetName,
+        domain,
+        intent,
+        operation
+      });
+      if (!target) {
+        if (ambiguousCandidates.length > 0) {
+          return {
+            success: false,
+            text: `Multiple items match \u2014 which one?
+${ambiguousCandidates.map((t) => `  - ${t}`).join("\n")}`
+          };
+        }
+        return {
+          success: false,
+          text: "I could not find that active item to skip."
+        };
+      }
+      const skipped = await service.skipOccurrence(target.id);
+      const fallback = `Skipped "${skipped.title}".`;
+      return {
+        success: true,
+        text: await renderLifeActionReply({
+          runtime,
+          message,
+          state,
+          intent,
+          scenario: "skipped_occurrence",
+          fallback,
+          context: {
+            skipped: {
+              title: skipped.title
+            }
+          }
+        }),
+        data: toActionData(skipped)
+      };
+    }
+    if (internalOp === "snooze_occurrence") {
+      const directOccurrenceId = detailString(details, "occurrenceId");
+      let resolvedTargetId;
+      if (directOccurrenceId) {
+        resolvedTargetId = directOccurrenceId;
+      } else {
+        const { match: target, ambiguousCandidates } = await resolveOccurrenceWithIntentFallback({
+          service,
+          target: targetName,
+          domain,
+          intent,
+          operation
+        });
+        if (!target) {
+          if (ambiguousCandidates.length > 0) {
+            return {
+              success: false,
+              text: `Multiple items match \u2014 which one?
+${ambiguousCandidates.map((t) => `  - ${t}`).join("\n")}`
+            };
+          }
+          return {
+            success: false,
+            text: "I could not find that active item to snooze."
+          };
+        }
+        resolvedTargetId = target.id;
+      }
+      const preset = detailString(details, "preset");
+      const minutes = detailNumber(details, "minutes");
+      const snoozed = await service.snoozeOccurrence(resolvedTargetId, {
+        preset,
+        minutes
+      });
+      const fallback = `Snoozed "${snoozed.title}".`;
+      return {
+        success: true,
+        text: await renderLifeActionReply({
+          runtime,
+          message,
+          state,
+          intent,
+          scenario: "snoozed_occurrence",
+          fallback,
+          context: {
+            snoozed: {
+              title: snoozed.title
+            },
+            preset: preset ?? null,
+            minutes: minutes ?? null
+          }
+        }),
+        data: toActionData(snoozed)
+      };
+    }
+    if (internalOp === "review_goal") {
+      const target = await resolveGoal(service, targetName, domain);
+      if (!target) {
+        const weeklyReview = await service.reviewGoalsForWeek();
+        if (weeklyReview.summary.totalGoals === 0) {
+          const overview = await service.getOverview();
+          const userQuery = messageText(message) || intent || "overview";
+          const fallback2 = formatOverviewForQuery(overview, userQuery);
+          return {
+            success: true,
+            text: await renderLifeActionReply({
+              runtime,
+              message,
+              state,
+              intent: userQuery,
+              scenario: "overview",
+              fallback: fallback2,
+              context: {
+                summary: overview.owner.summary,
+                occurrenceTitles: overview.owner.occurrences.slice(0, 6).map((occurrence) => occurrence.title),
+                goalTitles: overview.owner.goals.slice(0, 3).map((goal) => goal.title)
+              }
+            }),
+            data: toActionData(overview)
+          };
+        }
+        const fallback = formatWeeklyGoalReview(weeklyReview);
+        return {
+          success: true,
+          text: await renderLifeActionReply({
+            runtime,
+            message,
+            state,
+            intent,
+            scenario: "weekly_goal_review",
+            fallback,
+            context: {
+              summary: weeklyReview.summary,
+              atRiskTitles: weeklyReview.atRisk.slice(0, 3).map((review2) => review2.goal.title),
+              needsAttentionTitles: weeklyReview.needsAttention.slice(0, 3).map((review2) => review2.goal.title),
+              onTrackTitles: weeklyReview.onTrack.slice(0, 3).map((review2) => review2.goal.title)
+            }
+          }),
+          data: toActionData(weeklyReview)
+        };
+      }
+      const review = await service.reviewGoal(target.goal.id);
+      return {
+        success: true,
+        text: review.summary.explanation,
+        data: toActionData(review)
+      };
+    }
+    if (internalOp === "policy_set_reminder") {
+      const intensityDetail = detailString(details, "intensity");
+      const intensity = intensityDetail === "minimal" || intensityDetail === "normal" || intensityDetail === "persistent" || intensityDetail === "high_priority_only" ? intensityDetail : void 0;
+      return applyOwnerPolicySetReminder({
+        runtime,
+        message,
+        intent,
+        resolveDefinition: resolveDefinitionFromIntent,
+        intensity,
+        target: targetName,
+        details
+      });
+    }
+    if (internalOp === "policy_configure_escalation") {
+      return applyOwnerPolicyConfigureEscalation({
+        runtime,
+        message,
+        intent,
+        resolveDefinition: resolveDefinitionFromIntent,
+        target: targetName,
+        timeoutMinutes: detailNumber(details, "timeoutMinutes"),
+        callAfterMinutes: detailNumber(details, "callAfterMinutes"),
+        details
+      });
+    }
+    return {
+      success: false,
+      text: "I didn't understand that life management request."
+    };
+  } catch (err) {
+    if (err instanceof LifeOpsServiceError) {
+      const fallback = buildLifeServiceErrorFallback(err, intent);
+      return {
+        success: false,
+        text: await renderLifeActionReply({
+          runtime,
+          message,
+          state,
+          intent,
+          scenario: "service_error",
+          fallback,
+          context: {
+            status: err.status,
+            operation
+          }
+        })
+      };
+    }
+    throw err;
+  }
+}
+export {
+  OWNER_OPERATION_CONTEXTS,
+  OWNER_OPERATION_ROLE_GATE,
+  OWNER_OPERATION_SUPPRESS_POST_ACTION_CONTINUATION,
+  OWNER_OPERATION_TAGS,
+  OWNER_OPERATION_VALIDATE,
+  resolveDefinitionFromIntent,
+  runLifeOperationHandler
+};
+//# sourceMappingURL=life.js.map