@elizaos/agent 2.0.0-alpha.144 → 2.0.0-alpha.151

package/packages/agent/src/actions/life.js

@@ -1,3379 +1 @@
-import { ModelType, parseJSONObjectFromText } from "@elizaos/core";
-import { getValidationKeywordTerms, textIncludesKeywordTerm, } from "@elizaos/shared/validation-keywords";
-import { buildNativeAppleReminderMetadata, } from "../lifeops/apple-reminders.js";
-import { resolveDefaultTimeZone, resolveDefaultWindowPolicy, } from "../lifeops/defaults.js";
-import { LifeOpsService, LifeOpsServiceError } from "../lifeops/service.js";
-import { addDaysToLocalDate, buildUtcDateFromLocalParts, getZonedDateParts, } from "../lifeops/time.js";
-import { gmailAction } from "./gmail.js";
-import { renderGroundedActionReply } from "./grounded-action-reply.js";
-import { extractLifeOperationWithLlm, } from "./life.extractor.js";
-import { extractGoalCreatePlanWithLlm, extractGoalUpdatePlanWithLlm, mergeGoalMetadataWithGrounding, } from "./life-goal-extractor.js";
-import { extractReminderIntensityWithLlm, extractTaskCreatePlanWithLlm, } from "./life-param-extractor.js";
-import { recentConversationTexts } from "./life-recent-context.js";
-import { extractUpdateFieldsWithLlm } from "./life-update-extractor.js";
-import { calendarReadUnavailableMessage, dayRange, detailArray, detailBoolean, detailNumber, detailObject, detailString, formatCalendarFeed, formatNextEventContext, formatOverviewForQuery, getGoogleCapabilityStatus, hasLifeOpsAccess, INTERNAL_URL, messageText, toActionData, weekRange, } from "./lifeops-google-helpers.js";
-import { extractExplicitTimeZoneFromText, normalizeExplicitTimeZoneToken, } from "./timezone-normalization.js";
-const LIFE_EMAIL_QUERY_TERMS = getValidationKeywordTerms("contextSignal.gmail.strong", {
-    includeAllLocales: true,
-});
-const LIFE_I18N_OPTS = { includeAllLocales: true };
-const LIFE_COMPLETE_TERMS = getValidationKeywordTerms("contextSignal.lifeops_complete.strong", LIFE_I18N_OPTS);
-const LIFE_SKIP_TERMS = getValidationKeywordTerms("contextSignal.lifeops_skip.strong", LIFE_I18N_OPTS);
-const LIFE_SNOOZE_TERMS = getValidationKeywordTerms("contextSignal.lifeops_snooze.strong", LIFE_I18N_OPTS);
-const LIFE_DELETE_TERMS = getValidationKeywordTerms("contextSignal.lifeops_delete.strong", LIFE_I18N_OPTS);
-const LIFE_UPDATE_TERMS = getValidationKeywordTerms("contextSignal.lifeops_update.strong", LIFE_I18N_OPTS);
-const LIFE_OVERVIEW_TERMS = getValidationKeywordTerms("contextSignal.lifeops_overview.strong", LIFE_I18N_OPTS);
-const LIFE_REMINDER_PREF_TERMS = getValidationKeywordTerms("contextSignal.lifeops_reminder_pref.strong", LIFE_I18N_OPTS);
-const LIFE_CALENDAR_TERMS = getValidationKeywordTerms("contextSignal.calendar.strong", LIFE_I18N_OPTS);
-const LIFE_CADENCE_TERMS = getValidationKeywordTerms("contextSignal.lifeops_cadence.strong", LIFE_I18N_OPTS);
-const LIFE_GOAL_TERMS = getValidationKeywordTerms("contextSignal.lifeops_goal.strong", LIFE_I18N_OPTS);
-const LIFE_ESCALATION_TERMS = getValidationKeywordTerms("contextSignal.lifeops_escalation.strong", LIFE_I18N_OPTS);
-const LIFE_PHONE_TERMS = getValidationKeywordTerms("contextSignal.lifeops_phone.strong", LIFE_I18N_OPTS);
-const LIFE_REVIEW_TERMS = getValidationKeywordTerms("contextSignal.lifeops_review.strong", LIFE_I18N_OPTS);
-const LIFE_LIFEOPS_STRONG_TERMS = getValidationKeywordTerms("contextSignal.lifeops.strong", LIFE_I18N_OPTS);
-const LIFE_AFFIRMATIVE_TERMS = getValidationKeywordTerms("contextSignal.affirmative.strong", LIFE_I18N_OPTS);
-const LIFE_NEGATIVE_TERMS = getValidationKeywordTerms("contextSignal.negative.strong", LIFE_I18N_OPTS);
-const LIFE_DRAFT_EDIT_TERMS = getValidationKeywordTerms("contextSignal.draft_edit.strong", LIFE_I18N_OPTS);
-const LIFE_TEMPORAL_NEXT_TERMS = getValidationKeywordTerms("contextSignal.temporal_next.strong", LIFE_I18N_OPTS);
-function textMatchesAnyTerm(text, terms) {
-    return terms.some((term) => textIncludesKeywordTerm(text, term));
-}
-const ACTION_TO_OPERATION = {
-    create: "create_definition",
-    create_goal: "create_goal",
-    update: "update_definition",
-    update_goal: "update_goal",
-    delete: "delete_definition",
-    delete_goal: "delete_goal",
-    complete: "complete_occurrence",
-    skip: "skip_occurrence",
-    snooze: "snooze_occurrence",
-    review: "review_goal",
-    phone: "capture_phone",
-    escalation: "configure_escalation",
-    reminder_preference: "set_reminder_preference",
-    calendar: "query_calendar_today",
-    next_event: "query_calendar_next",
-    email: "query_email",
-    overview: "query_overview",
-};
-// CADENCE_HINT_RE removed — cadence detection uses i18n LIFE_CADENCE_TERMS
-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;
-/** Maximum age (ms) for a deferred draft before it expires. */
-const DRAFT_EXPIRY_MS = 5 * 60 * 1000; // 5 minutes
-/** Maximum conversation turns before a deferred draft expires. */
-const DRAFT_MAX_TURNS = 3;
-function normalizeLifeTimeZoneToken(value) {
-    return normalizeExplicitTimeZoneToken(value);
-}
-function extractLifeTimeZoneFromText(value) {
-    return extractExplicitTimeZoneFromText(value);
-}
-// ── Intent classifier ─────────────────────────────────
-export function classifyIntent(intent) {
-    // All matching is i18n-aware via validation keyword terms.
-    // English words are included in the base terms so no regex needed.
-    // Reminder preference — check early
-    if (textMatchesAnyTerm(intent, LIFE_REMINDER_PREF_TERMS)) {
-        return "set_reminder_preference";
-    }
-    // Update — check before calendar so "edit my workout schedule" doesn't hit calendar
-    if (textMatchesAnyTerm(intent, LIFE_UPDATE_TERMS)) {
-        if (textMatchesAnyTerm(intent, LIFE_GOAL_TERMS))
-            return "update_goal";
-        return "update_definition";
-    }
-    // Escalation config — check before phone capture
-    if (textMatchesAnyTerm(intent, LIFE_ESCALATION_TERMS))
-        return "configure_escalation";
-    // Phone capture
-    if (textMatchesAnyTerm(intent, LIFE_PHONE_TERMS))
-        return "capture_phone";
-    // Review — check before calendar
-    if (textMatchesAnyTerm(intent, LIFE_REVIEW_TERMS))
-        return "review_goal";
-    // Delete — check before calendar
-    if (textMatchesAnyTerm(intent, LIFE_DELETE_TERMS)) {
-        if (textMatchesAnyTerm(intent, LIFE_GOAL_TERMS))
-            return "delete_goal";
-        return "delete_definition";
-    }
-    // Completion
-    if (looksLikeCompletionReport(intent))
-        return "complete_occurrence";
-    // Skip
-    if (textMatchesAnyTerm(intent, LIFE_SKIP_TERMS))
-        return "skip_occurrence";
-    // Snooze
-    if (textMatchesAnyTerm(intent, LIFE_SNOOZE_TERMS))
-        return "snooze_occurrence";
-    // Calendar query — only when not a lifeops create or lifeops item reference
-    if (!looksLikeDefinitionCreateIntent(intent) &&
-        !looksLikeGoalCreateIntent(intent) &&
-        !textMatchesAnyTerm(intent, LIFE_LIFEOPS_STRONG_TERMS) &&
-        textMatchesAnyTerm(intent, LIFE_CALENDAR_TERMS)) {
-        // Sub-classify: next event vs today/tomorrow/week
-        const lower = intent.toLowerCase();
-        if (textMatchesAnyTerm(lower, LIFE_TEMPORAL_NEXT_TERMS))
-            return "query_calendar_next";
-        return "query_calendar_today";
-    }
-    // Email query
-    if (textMatchesAnyTerm(intent, LIFE_EMAIL_QUERY_TERMS))
-        return "query_email";
-    // Overview
-    if (textMatchesAnyTerm(intent, LIFE_OVERVIEW_TERMS))
-        return "query_overview";
-    // Create definition (has cadence hint)
-    if (looksLikeDefinitionCreateIntent(intent))
-        return "create_definition";
-    // Create goal (goal mention without cadence)
-    if (looksLikeGoalCreateIntent(intent))
-        return "create_goal";
-    // Default: create a task/habit/routine
-    return "create_definition";
-}
-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) {
-        return {
-            operation: extracted.operation,
-            confidence: extracted.confidence,
-            missing: extracted.missing,
-            shouldAct: false,
-        };
-    }
-    return {
-        operation: extracted.operation,
-        confidence: extracted.confidence,
-        missing: extracted.missing,
-        shouldAct: true,
-    };
-}
-function looksLikeDefinitionCreateIntent(text) {
-    return hasCadenceHint(text);
-}
-function looksLikeGoalCreateIntent(text) {
-    return textMatchesAnyTerm(text, LIFE_GOAL_TERMS) && !hasCadenceHint(text);
-}
-function hasCadenceHint(text) {
-    return textMatchesAnyTerm(text, LIFE_CADENCE_TERMS);
-}
-function shouldForceLifeCreateExecution(args) {
-    if (args.operation !== "create_definition") {
-        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 looksLikeCompletionReport(text) {
-    // Exclude overview queries — these mention "done/finish" but ask what's remaining
-    if (textMatchesAnyTerm(text, LIFE_OVERVIEW_TERMS)) {
-        return false;
-    }
-    // Exclude create-intent with cadence — "create a habit until I complete it"
-    if (textMatchesAnyTerm(text, LIFE_CADENCE_TERMS)) {
-        return false;
-    }
-    return textMatchesAnyTerm(text, LIFE_COMPLETE_TERMS);
-}
-// ── Helpers ───────────────────────────────────────────
-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);
-}
-function coerceDeferredLifeDraft(value) {
-    if (!value || typeof value !== "object") {
-        return null;
-    }
-    const record = value;
-    const operation = record.operation;
-    const intent = typeof record.intent === "string" ? record.intent.trim() : "";
-    const request = record.request && typeof record.request === "object"
-        ? record.request
-        : null;
-    const createdAt = typeof record.createdAt === "number" && Number.isFinite(record.createdAt)
-        ? record.createdAt
-        : undefined;
-    if (!request || !intent) {
-        return null;
-    }
-    const title = typeof request.title === "string" ? request.title.trim() : "";
-    if (!title) {
-        return null;
-    }
-    if (operation === "create_definition") {
-        const kind = typeof request.kind === "string"
-            ? request.kind
-            : null;
-        const cadence = request.cadence;
-        if (!kind || !cadence) {
-            return null;
-        }
-        return {
-            createdAt,
-            intent,
-            operation,
-            request: {
-                cadence,
-                description: typeof request.description === "string"
-                    ? request.description
-                    : undefined,
-                goalRef: typeof request.goalRef === "string" ? request.goalRef : undefined,
-                kind,
-                priority: typeof request.priority === "number" ? request.priority : undefined,
-                progressionRule: request.progressionRule,
-                reminderPlan: request.reminderPlan,
-                timezone: typeof request.timezone === "string" ? request.timezone : undefined,
-                title,
-                metadata: request.metadata && typeof request.metadata === "object"
-                    ? request.metadata
-                    : undefined,
-                windowPolicy: request.windowPolicy,
-                websiteAccess: request.websiteAccess,
-            },
-        };
-    }
-    if (operation === "create_goal") {
-        return {
-            createdAt,
-            intent,
-            operation,
-            request: {
-                cadence: request.cadence,
-                description: typeof request.description === "string"
-                    ? request.description
-                    : undefined,
-                metadata: request.metadata && typeof request.metadata === "object"
-                    ? request.metadata
-                    : undefined,
-                successCriteria: request.successCriteria,
-                supportStrategy: request.supportStrategy,
-                title,
-            },
-        };
-    }
-    return null;
-}
-function stateActionResults(state) {
-    if (!state || typeof state !== "object") {
-        return [];
-    }
-    const stateRecord = state;
-    const data = stateRecord.data && typeof stateRecord.data === "object"
-        ? stateRecord.data
-        : undefined;
-    const providerResults = data?.providers && typeof data.providers === "object"
-        ? data.providers
-        : undefined;
-    const providerActionState = providerResults?.ACTION_STATE &&
-        typeof providerResults.ACTION_STATE === "object"
-        ? providerResults.ACTION_STATE
-        : undefined;
-    const providerActionStateData = providerActionState?.data && typeof providerActionState.data === "object"
-        ? providerActionState.data
-        : undefined;
-    const providerRecentMessages = providerResults?.RECENT_MESSAGES &&
-        typeof providerResults.RECENT_MESSAGES === "object"
-        ? providerResults.RECENT_MESSAGES
-        : undefined;
-    const providerRecentMessagesData = providerRecentMessages?.data &&
-        typeof providerRecentMessages.data === "object"
-        ? providerRecentMessages.data
-        : undefined;
-    const candidates = [
-        data?.actionResults,
-        providerActionStateData?.actionResults,
-        providerActionStateData?.recentActionMemories,
-        providerRecentMessagesData?.actionResults,
-    ].filter(Array.isArray);
-    if (candidates.length === 0) {
-        return [];
-    }
-    return candidates.flatMap((entries) => entries.flatMap((entry) => {
-        if (!entry || typeof entry !== "object") {
-            return [];
-        }
-        if ("content" in entry) {
-            const content = entry.content &&
-                typeof entry.content === "object"
-                ? entry
-                    .content
-                : null;
-            if (!content) {
-                return [];
-            }
-            const contentData = content.data && typeof content.data === "object"
-                ? { ...content.data }
-                : {};
-            if (typeof content.actionName === "string" &&
-                typeof contentData.actionName !== "string") {
-                contentData.actionName = content.actionName;
-            }
-            return [
-                {
-                    success: content.actionStatus !== "failed",
-                    text: typeof content.text === "string" ? content.text : undefined,
-                    data: contentData,
-                    error: typeof content.error === "string" ? content.error : undefined,
-                },
-            ];
-        }
-        return [entry];
-    }));
-}
-function stateMessageDrafts(state) {
-    if (!state || typeof state !== "object") {
-        return [];
-    }
-    const stateRecord = state;
-    const data = stateRecord.data && typeof stateRecord.data === "object"
-        ? stateRecord.data
-        : undefined;
-    const providerResults = data?.providers && typeof data.providers === "object"
-        ? data.providers
-        : undefined;
-    const providerRecentMessages = providerResults?.RECENT_MESSAGES &&
-        typeof providerResults.RECENT_MESSAGES === "object"
-        ? providerResults.RECENT_MESSAGES
-        : undefined;
-    const providerRecentMessagesData = providerRecentMessages?.data &&
-        typeof providerRecentMessages.data === "object"
-        ? providerRecentMessages.data
-        : undefined;
-    const recentMessagesData = [
-        stateRecord.recentMessagesData,
-        stateRecord.recentMessages,
-        providerRecentMessagesData?.recentMessages,
-    ].find(Array.isArray);
-    if (!Array.isArray(recentMessagesData)) {
-        return [];
-    }
-    const drafts = [];
-    for (const item of recentMessagesData) {
-        if (!item || typeof item !== "object") {
-            continue;
-        }
-        const content = item.content;
-        if (!content || typeof content !== "object") {
-            continue;
-        }
-        const contentRecord = content;
-        const candidate = coerceDeferredLifeDraft(contentRecord.lifeDraft) ??
-            coerceDeferredLifeDraft(contentRecord.data && typeof contentRecord.data === "object"
-                ? contentRecord.data.lifeDraft
-                : undefined);
-        if (candidate) {
-            drafts.push(candidate);
-        }
-    }
-    return drafts;
-}
-function stateRecentMessageEntries(state) {
-    if (!state || typeof state !== "object") {
-        return [];
-    }
-    const stateRecord = state;
-    const data = stateRecord.data && typeof stateRecord.data === "object"
-        ? stateRecord.data
-        : undefined;
-    const providerResults = data?.providers && typeof data.providers === "object"
-        ? data.providers
-        : undefined;
-    const providerRecentMessages = providerResults?.RECENT_MESSAGES &&
-        typeof providerResults.RECENT_MESSAGES === "object"
-        ? providerResults.RECENT_MESSAGES
-        : undefined;
-    const providerRecentMessagesData = providerRecentMessages?.data &&
-        typeof providerRecentMessages.data === "object"
-        ? providerRecentMessages.data
-        : undefined;
-    const recentMessagesData = [
-        stateRecord.recentMessagesData,
-        stateRecord.recentMessages,
-        providerRecentMessagesData?.recentMessages,
-    ].find(Array.isArray);
-    if (!Array.isArray(recentMessagesData)) {
-        return [];
-    }
-    return recentMessagesData.filter((item) => Boolean(item) && typeof item === "object");
-}
-function isDeferredLifeDraftMessageEntry(item) {
-    const content = item.content && typeof item.content === "object"
-        ? item.content
-        : null;
-    if (!content) {
-        return false;
-    }
-    return Boolean(coerceDeferredLifeDraft(content.lifeDraft) ??
-        coerceDeferredLifeDraft(content.data && typeof content.data === "object"
-            ? content.data.lifeDraft
-            : undefined));
-}
-function countTurnsSinceLatestDeferredLifeDraft(state) {
-    const entries = stateRecentMessageEntries(state);
-    if (entries.length === 0) {
-        return undefined;
-    }
-    let latestDraftIndex = -1;
-    for (let index = entries.length - 1; index >= 0; index--) {
-        if (isDeferredLifeDraftMessageEntry(entries[index])) {
-            latestDraftIndex = index;
-            break;
-        }
-    }
-    if (latestDraftIndex < 0) {
-        return undefined;
-    }
-    let turns = 0;
-    for (const entry of entries.slice(latestDraftIndex + 1)) {
-        const content = entry.content && typeof entry.content === "object"
-            ? entry.content
-            : null;
-        if (!content || isDeferredLifeDraftMessageEntry(entry)) {
-            continue;
-        }
-        if (typeof content.text === "string" && content.text.trim().length > 0) {
-            turns++;
-        }
-    }
-    return turns;
-}
-function latestDeferredLifeDraft(state) {
-    for (const result of [...stateActionResults(state)].reverse()) {
-        const resultData = result.data && typeof result.data === "object"
-            ? result.data
-            : null;
-        const completedCreate = result.success &&
-            resultData &&
-            !coerceDeferredLifeDraft(resultData.lifeDraft) &&
-            ((resultData.definition && typeof resultData.definition === "object") ||
-                (resultData.goal && typeof resultData.goal === "object"));
-        if (completedCreate) {
-            return null;
-        }
-        const candidate = coerceDeferredLifeDraft(result.data?.lifeDraft);
-        if (candidate) {
-            return candidate;
-        }
-    }
-    const messageDrafts = stateMessageDrafts(state);
-    return messageDrafts.length > 0
-        ? messageDrafts[messageDrafts.length - 1]
-        : null;
-}
-function looksLikeDeferredLifeConfirmation(text) {
-    const normalized = text.trim().toLowerCase();
-    if (!normalized)
-        return false;
-    if (textMatchesAnyTerm(normalized, LIFE_NEGATIVE_TERMS))
-        return false;
-    if (textMatchesAnyTerm(normalized, LIFE_DRAFT_EDIT_TERMS))
-        return false;
-    return textMatchesAnyTerm(normalized, LIFE_AFFIRMATIVE_TERMS);
-}
-function normalizeDeferredLifeDraftReference(value) {
-    return normalizeIntentText(value ?? "")
-        .replace(/\b(the|that|this|a|an|my|routine|habit|task|goal|reminder)\b/g, " ")
-        .replace(/\s+/g, " ")
-        .trim();
-}
-function matchesDeferredLifeDraftTitle(value, draft) {
-    if (!draft) {
-        return false;
-    }
-    const normalizedValue = normalizeDeferredLifeDraftReference(value);
-    const normalizedDraftTitle = normalizeDeferredLifeDraftReference(draft.request.title);
-    if (!normalizedValue || !normalizedDraftTitle) {
-        return false;
-    }
-    return (normalizedValue === normalizedDraftTitle ||
-        normalizedValue.includes(normalizedDraftTitle) ||
-        normalizedDraftTitle.includes(normalizedValue));
-}
-function deferredLifeDraftExpiryReason(args) {
-    if (!args.draft) {
-        return null;
-    }
-    if (args.draft.createdAt) {
-        const ageMs = Date.now() - args.draft.createdAt;
-        if (ageMs >= DRAFT_EXPIRY_MS) {
-            return "age";
-        }
-    }
-    if (typeof args.turnsSinceDraft === "number" &&
-        args.turnsSinceDraft >= DRAFT_MAX_TURNS) {
-        return "turns";
-    }
-    return null;
-}
-function looksLikeDeferredLifeDraftEdit(text) {
-    const normalized = normalizeIntentText(text);
-    if (!normalized || looksLikeDeferredLifeConfirmation(text))
-        return false;
-    if (textMatchesAnyTerm(normalized, LIFE_NEGATIVE_TERMS))
-        return false;
-    if (textMatchesAnyTerm(normalized, LIFE_DRAFT_EDIT_TERMS))
-        return true;
-    return hasCadenceHint(normalized) || /\b\d+\b/.test(normalized);
-}
-async function extractDeferredLifeDraftFollowupWithLlm(args) {
-    if (typeof args.runtime.useModel !== "function") {
-        return null;
-    }
-    const recentConversation = await recentConversationTexts({
-        runtime: args.runtime,
-        message: args.message,
-        state: args.state,
-        limit: 12,
-    });
-    const prompt = [
-        "Decide how the assistant should interpret the user's follow-up to a previewed LifeOps draft that has not been saved yet.",
-        "Use the current message, the draft summary, and recent conversation.",
-        "The user may speak in any language.",
-        "",
-        "Return ONLY valid JSON with exactly this shape:",
-        '{"mode":"confirm"|"edit"|"cancel"|"none"}',
-        "",
-        "Choose confirm when the user clearly approves saving the current draft now.",
-        "Choose edit when the user wants to change the draft or continue specifying it before saving.",
-        "Choose cancel when the user says not to save it, never mind, not yet, hold off, or equivalent.",
-        "Choose none when the follow-up is unrelated or too ambiguous to attach to the draft.",
-        "",
-        "Previewed draft:",
-        stringifyDeferredLifeDraftForPrompt(args.draft),
-        "",
-        `Current user message: ${JSON.stringify(args.currentText)}`,
-        `Recent conversation: ${JSON.stringify(recentConversation.join("\n"))}`,
-    ].join("\n");
-    try {
-        const result = await args.runtime.useModel(ModelType.TEXT_LARGE, {
-            prompt,
-        });
-        const raw = typeof result === "string" ? result : "";
-        const parsed = parseJSONObjectFromText(raw);
-        const mode = parsed && typeof parsed.mode === "string"
-            ? parsed.mode.trim().toLowerCase()
-            : "";
-        switch (mode) {
-            case "confirm":
-            case "edit":
-            case "cancel":
-                return mode;
-            default:
-                return null;
-        }
-    }
-    catch {
-        return null;
-    }
-}
-function stringifyDeferredLifeDraftForPrompt(draft) {
-    if (draft.operation === "create_definition") {
-        return JSON.stringify({
-            operation: draft.operation,
-            title: draft.request.title,
-            kind: draft.request.kind,
-            cadence: draft.request.cadence,
-            timezone: draft.request.timezone ?? null,
-            description: draft.request.description ?? null,
-        });
-    }
-    return JSON.stringify({
-        operation: draft.operation,
-        title: draft.request.title,
-        cadence: draft.request.cadence ?? null,
-        description: draft.request.description ?? null,
-    });
-}
-function resolveDeferredLifeDraftReuseMode(args) {
-    if (!args.draft) {
-        return null;
-    }
-    if (deferredLifeDraftExpiryReason(args)) {
-        return null;
-    }
-    if (detailBoolean(args.details, "confirmed") === true) {
-        return "confirm";
-    }
-    const words = args.currentText.trim().split(/\s+/).filter(Boolean);
-    const isConfirmationFollowup = words.length > 0 &&
-        words.length <= 6 &&
-        !hasCadenceHint(args.currentText.toLowerCase()) &&
-        looksLikeDeferredLifeConfirmation(args.currentText);
-    if (isConfirmationFollowup) {
-        if (args.explicitAction &&
-            ACTION_TO_OPERATION[args.explicitAction] !== args.draft.operation) {
-            return null;
-        }
-        return "confirm";
-    }
-    const explicitReferenceMatchesDraft = matchesDeferredLifeDraftTitle(args.title, args.draft) ||
-        matchesDeferredLifeDraftTitle(args.target, args.draft);
-    if (looksLikeDeferredLifeConfirmation(args.currentText)) {
-        if (args.explicitAction &&
-            ACTION_TO_OPERATION[args.explicitAction] !== args.draft.operation) {
-            return null;
-        }
-        if (explicitReferenceMatchesDraft) {
-            return "confirm";
-        }
-    }
-    const normalizedCurrentText = normalizeIntentText(args.currentText);
-    const normalizedParamsIntent = typeof args.paramsIntent === "string" && args.paramsIntent.trim().length > 0
-        ? normalizeIntentText(args.paramsIntent)
-        : "";
-    if (normalizedParamsIntent &&
-        normalizedParamsIntent !== normalizedCurrentText &&
-        !looksLikeDeferredLifeConfirmation(args.paramsIntent ?? "")) {
-        return null;
-    }
-    if (args.explicitAction &&
-        ACTION_TO_OPERATION[args.explicitAction] !== args.draft.operation) {
-        return null;
-    }
-    if (args.llmMode === "confirm" || args.llmMode === "edit") {
-        return args.llmMode;
-    }
-    if (args.title || args.target) {
-        return null;
-    }
-    return looksLikeDeferredLifeDraftEdit(args.currentText) ? "edit" : 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(undefined, {
-                month: "short",
-                day: "numeric",
-                hour: "numeric",
-                minute: "2-digit",
-            }));
-        }
-    }
-    return hints.length > 0
-        ? `${occurrence.title} (${hints.join(", ")})`
-        : occurrence.title;
-}
-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);
-    // Exact ID match
-    const byId = all.find((o) => o.id === target);
-    if (byId)
-        return { match: byId, ambiguousCandidates: [] };
-    // Exact normalized-title match
-    const exactMatches = all.filter((o) => normalizeTitle(o.title) === normalized);
-    if (exactMatches.length === 1) {
-        return { match: exactMatches[0], ambiguousCandidates: [] };
-    }
-    if (exactMatches.length > 1) {
-        return {
-            match: null,
-            ambiguousCandidates: exactMatches.map(formatOccurrenceDisambiguationLabel),
-        };
-    }
-    // Substring matches — disambiguate when multiple
-    const substringMatches = all.filter((o) => normalizeTitle(o.title).includes(normalized));
-    if (substringMatches.length === 1) {
-        return { match: substringMatches[0], ambiguousCandidates: [] };
-    }
-    if (substringMatches.length > 1) {
-        // Prefer startsWith over generic includes
-        const startsWithMatches = substringMatches.filter((o) => normalizeTitle(o.title).startsWith(normalized));
-        if (startsWithMatches.length === 1) {
-            return { match: startsWithMatches[0], ambiguousCandidates: [] };
-        }
-        if (startsWithMatches.length > 1) {
-            return {
-                match: null,
-                ambiguousCandidates: startsWithMatches.map(formatOccurrenceDisambiguationLabel),
-            };
-        }
-        // Still ambiguous — return candidates for the caller to list
-        return {
-            match: null,
-            ambiguousCandidates: substringMatches.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[0], ambiguousCandidates: [] };
-        }
-        if (tokenSetMatches.length > 1) {
-            return {
-                match: null,
-                ambiguousCandidates: tokenSetMatches.map(formatOccurrenceDisambiguationLabel),
-            };
-        }
-    }
-    return { match: null, ambiguousCandidates: [] };
-}
-function deriveOccurrenceTargetFromIntent(intent, operation) {
-    const normalized = normalizeLifeInputText(intent);
-    if (!normalized) {
-        return null;
-    }
-    let candidate = normalized;
-    if (operation === "snooze_occurrence") {
-        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_occurrence") {
-        candidate = candidate
-            .replace(/^(?:please\s+)?(?:skip|pass on)\s+/i, "")
-            .replace(/\b(?:today|tonight|for now)\b.*$/i, "")
-            .trim();
-    }
-    else if (operation === "complete_occurrence") {
-        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) {
-    switch (cadence.kind) {
-        case "once": {
-            const dueAt = new Date(cadence.dueAt);
-            if (Number.isNaN(dueAt.getTime())) {
-                return "once";
-            }
-            return `once on ${dueAt.toLocaleString(undefined, {
-                month: "short",
-                day: "numeric",
-                hour: "numeric",
-                minute: "2-digit",
-                timeZone: resolveDefaultTimeZone(),
-            })}`;
-        }
-        case "daily":
-            return `every day in ${cadence.windows.join(", ")}`;
-        case "times_per_day":
-            return cadence.slots
-                .map((slot) => slot.label?.trim() || `${slot.minuteOfDay}`)
-                .filter(Boolean)
-                .join(" and ");
-        case "interval":
-            return `every ${cadence.everyMinutes} minutes in ${cadence.windows.join(", ")}`;
-        case "weekly":
-            return `weekly on ${cadence.weekdays
-                .map((weekday) => [
-                "Sunday",
-                "Monday",
-                "Tuesday",
-                "Wednesday",
-                "Thursday",
-                "Friday",
-                "Saturday",
-            ][weekday] ?? String(weekday))
-                .join(", ")}`;
-    }
-}
-function extractNaturalTimePhrase(intent) {
-    const normalized = normalizeLifeInputText(intent).toLowerCase();
-    if (/\bmornings?\s+only\b|\bmornings?\b/.test(normalized)) {
-        return "mornings now";
-    }
-    if (/\bafternoons?\s+only\b|\bafternoons?\b/.test(normalized)) {
-        return "afternoons now";
-    }
-    if (/\bevenings?\s+only\b|\bevenings?\b/.test(normalized)) {
-        return "evenings now";
-    }
-    if (/\bnights?\s+only\b|\bnights?\b/.test(normalized)) {
-        return "nights now";
-    }
-    const timeMatch = normalized.match(/\b(\d{1,2}(?::\d{2})?\s*(?:am|pm))\b/);
-    if (timeMatch?.[1]) {
-        return `${timeMatch[1].replace(/\s+/g, "")} now`;
-    }
-    return null;
-}
-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;
-    const timePhrase = extractNaturalTimePhrase(args.intent);
-    switch (args.scenario) {
-        case "updated_definition":
-            if (title && timePhrase) {
-                return `${title} is set for ${timePhrase}.`;
-            }
-            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_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.";
-}
-// ── Calendar/email formatters ─────────────────────────
-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));
-    const presets = {
-        1: [9 * 60],
-        2: [8 * 60, 21 * 60],
-        3: [8 * 60, 13 * 60, 20 * 60],
-        4: [8 * 60, 12 * 60, 16 * 60, 20 * 60],
-        5: [8 * 60, 11 * 60, 14 * 60, 17 * 60, 20 * 60],
-        6: [8 * 60, 10 * 60, 12 * 60, 14 * 60, 17 * 60, 20 * 60],
-    };
-    const minutes = presets[normalizedCount] ?? presets[1];
-    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 addYearsToLocalDate(dateOnly, yearDelta) {
-    const utcDate = new Date(Date.UTC(dateOnly.year + yearDelta, dateOnly.month - 1, dateOnly.day, 12));
-    return {
-        year: utcDate.getUTCFullYear(),
-        month: utcDate.getUTCMonth() + 1,
-        day: utcDate.getUTCDate(),
-    };
-}
-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 resolveAlarmDayOffset(intent) {
-    const lower = normalizeLifeInputText(intent).toLowerCase();
-    if (/\btomorrow\b/.test(lower))
-        return 1;
-    if (/\b(today|tonight)\b/.test(lower))
-        return 0;
-    return null;
-}
-function buildOneOffDueAtFromMinuteOfDay(args) {
-    const now = args.now ?? new Date();
-    const timeZone = args.timeZone ?? resolveDefaultTimeZone();
-    const nowParts = getZonedDateParts(now, timeZone);
-    let localDate = {
-        year: nowParts.year,
-        month: nowParts.month,
-        day: nowParts.day,
-    };
-    const explicitDate = typeof args.intent === "string"
-        ? parseExplicitLocalDateForLifeRequest(args.intent, timeZone, now)
-        : null;
-    if (explicitDate) {
-        localDate = explicitDate;
-    }
-    const explicitDayOffset = typeof args.intent === "string" ? resolveAlarmDayOffset(args.intent) : null;
-    if (explicitDate === null && explicitDayOffset !== null) {
-        localDate = addDaysToLocalDate(localDate, explicitDayOffset);
-    }
-    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()) {
-        if (explicitDate && !explicitDate.explicitYear) {
-            localDate = addYearsToLocalDate(localDate, 1);
-            candidate = buildCandidate();
-        }
-        else if (explicitDate === null && explicitDayOffset === null) {
-            localDate = addDaysToLocalDate(localDate, 1);
-            candidate = buildCandidate();
-        }
-    }
-    return candidate.toISOString();
-}
-function parseExplicitLocalDateForLifeRequest(value, timeZone, now = new Date()) {
-    const normalized = normalizeLifeInputText(value).toLowerCase();
-    const localToday = getZonedDateParts(now, timeZone);
-    const monthMap = {
-        january: 1,
-        jan: 1,
-        february: 2,
-        feb: 2,
-        march: 3,
-        mar: 3,
-        april: 4,
-        apr: 4,
-        may: 5,
-        june: 6,
-        jun: 6,
-        july: 7,
-        jul: 7,
-        august: 8,
-        aug: 8,
-        september: 9,
-        sept: 9,
-        sep: 9,
-        october: 10,
-        oct: 10,
-        november: 11,
-        nov: 11,
-        december: 12,
-        dec: 12,
-    };
-    const weekdayMap = {
-        sunday: 0,
-        sun: 0,
-        monday: 1,
-        mon: 1,
-        tuesday: 2,
-        tue: 2,
-        tues: 2,
-        wednesday: 3,
-        wed: 3,
-        thursday: 4,
-        thu: 4,
-        thur: 4,
-        thurs: 4,
-        friday: 5,
-        fri: 5,
-        saturday: 6,
-        sat: 6,
-    };
-    const isoMatch = normalized.match(/\b(\d{4})-(\d{1,2})-(\d{1,2})\b/);
-    if (isoMatch) {
-        return {
-            year: Number(isoMatch[1]),
-            month: Number(isoMatch[2]),
-            day: Number(isoMatch[3]),
-            explicitYear: true,
-        };
-    }
-    const monthNameMatch = normalized.match(/\b(jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|jun(?:e)?|jul(?:y)?|aug(?:ust)?|sep(?:t(?:ember)?)?|oct(?:ober)?|nov(?:ember)?|dec(?:ember)?)\.?\s+(\d{1,2})(?:st|nd|rd|th)?(?:,?\s+(\d{4}))?\b/i);
-    if (monthNameMatch) {
-        return {
-            year: monthNameMatch[3] ? Number(monthNameMatch[3]) : localToday.year,
-            month: monthMap[monthNameMatch[1].toLowerCase().replace(/\./g, "")],
-            day: Number(monthNameMatch[2]),
-            explicitYear: Boolean(monthNameMatch[3]),
-        };
-    }
-    const numericMatch = normalized.match(/\b(\d{1,2})[/-](\d{1,2})(?:[/-](\d{2,4}))?\b/);
-    if (numericMatch) {
-        const yearRaw = numericMatch[3];
-        const year = yearRaw === undefined
-            ? localToday.year
-            : yearRaw.length === 2
-                ? 2000 + Number(yearRaw)
-                : Number(yearRaw);
-        return {
-            year,
-            month: Number(numericMatch[1]),
-            day: Number(numericMatch[2]),
-            explicitYear: Boolean(yearRaw),
-        };
-    }
-    const weekdayMatch = normalized.match(/\b(?:(this|next)\s+)?(sun(?:day)?|mon(?:day)?|tue(?:s(?:day)?)?|wed(?:nesday)?|thu(?:r(?:s(?:day)?)?)?|fri(?:day)?|sat(?:urday)?)\b/i);
-    if (!weekdayMatch) {
-        return null;
-    }
-    const weekdayToken = weekdayMatch[2]?.toLowerCase();
-    const targetWeekday = weekdayToken ? weekdayMap[weekdayToken] : undefined;
-    if (targetWeekday === undefined) {
-        return null;
-    }
-    const qualifier = weekdayMatch[1]?.toLowerCase() ?? "";
-    const currentWeekday = new Date(Date.UTC(localToday.year, Math.max(0, localToday.month - 1), localToday.day, 12)).getUTCDay();
-    let delta = (targetWeekday - currentWeekday + 7) % 7;
-    if (qualifier === "next") {
-        delta = delta === 0 ? 7 : delta + 7;
-    }
-    const resolved = addDaysToLocalDate({
-        year: localToday.year,
-        month: localToday.month,
-        day: localToday.day,
-    }, delta);
-    return {
-        ...resolved,
-        explicitYear: false,
-    };
-}
-function mergeMetadataRecords(...records) {
-    const merged = Object.assign({}, ...records.filter((record) => record != null && Object.keys(record).length > 0));
-    return Object.keys(merged).length > 0 ? merged : undefined;
-}
-function extractExplicitDailySlots(intent) {
-    const tokens = [
-        ...intent.matchAll(/\b(\d{1,2}(?::\d{2})?\s*(?:am|pm)|noon|midnight)\b/gi),
-    ].map((match) => match[1]);
-    const seen = 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 undefined;
-    }
-    const record = value;
-    const cadenceKind = typeof record.kind === "string"
-        ? normalizeLifeInputText(record.kind).toLowerCase()
-        : typeof record.type === "string"
-            ? normalizeLifeInputText(record.type).toLowerCase()
-            : "";
-    if (!cadenceKind) {
-        return undefined;
-    }
-    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 undefined;
-    }
-    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 undefined;
-    }
-    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 undefined;
-}
-/**
- * Convert LLM-extracted params into a typed LifeOpsCadence.
- * Returns null when the LLM output is insufficient to construct a
- * valid cadence, letting the caller fall back to regex-derived values.
- */
-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({
-                        intent: context?.intent,
-                        minuteOfDay: timeOfDayMinute,
-                        now: context?.now,
-                        timeZone: effectiveTimeZone,
-                    }),
-                },
-            };
-        }
-        return { cadence: { kind: "once", dueAt: new Date().toISOString() } };
-    }
-    if (kind === "daily") {
-        if (explicitSlots.length >= 2) {
-            return {
-                cadence: {
-                    kind: "times_per_day",
-                    slots: explicitSlots.map((slot) => ({
-                        ...slot,
-                        durationMinutes: slot.durationMinutes ?? slotDuration,
-                    })),
-                    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 ?? undefined,
-                durationMinutes: typeof params.durationMinutes === "number" &&
-                    params.durationMinutes > 0
-                    ? params.durationMinutes
-                    : undefined,
-            },
-        };
-    }
-    if (kind === "times_per_day") {
-        if (explicitSlots.length >= 2) {
-            return {
-                cadence: {
-                    kind: "times_per_day",
-                    slots: explicitSlots.map((slot) => ({
-                        ...slot,
-                        durationMinutes: slot.durationMinutes ?? slotDuration,
-                    })),
-                    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
-                        : undefined),
-                maxOccurrencesPerDay: currentCadence.kind === "interval"
-                    ? currentCadence.maxOccurrencesPerDay
-                    : undefined,
-                durationMinutes: currentCadence.kind === "interval"
-                    ? currentCadence.durationMinutes
-                    : undefined,
-                visibilityLeadMinutes: currentCadence.kind === "interval"
-                    ? currentCadence.visibilityLeadMinutes
-                    : undefined,
-                visibilityLagMinutes: currentCadence.kind === "interval"
-                    ? currentCadence.visibilityLagMinutes
-                    : undefined,
-            },
-        };
-    }
-    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
-                        : undefined,
-                    visibilityLagMinutes: currentCadence.kind === "weekly"
-                        ? currentCadence.visibilityLagMinutes
-                        : undefined,
-                },
-                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
-                    : undefined,
-                visibilityLagMinutes: currentCadence.kind === "weekly"
-                    ? currentCadence.visibilityLagMinutes
-                    : undefined,
-            },
-            windowPolicy: currentWindowPolicy.windows.some((window) => (requestedWindows.length > 0
-                ? requestedWindows
-                : ["morning"]).includes(window.name))
-                ? undefined
-                : 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
-                    : undefined,
-                visibilityLagMinutes: currentCadence.kind === "daily"
-                    ? currentCadence.visibilityLagMinutes
-                    : undefined,
-            },
-        };
-    }
-    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 describeReminderIntensity(intensity) {
-    switch (intensity) {
-        case "minimal":
-            return "minimal";
-        case "normal":
-            return "normal";
-        case "persistent":
-            return "persistent";
-        case "high_priority_only":
-            return "high priority only";
-    }
-    return "normal";
-}
-// ── Main action ───────────────────────────────────────
-export const lifeAction = {
-    name: "LIFE",
-    similes: [
-        "MANAGE_LIFEOPS",
-        "QUERY_LIFEOPS",
-        "CREATE_TASK",
-        "CREATE_HABIT",
-        "CREATE_GOAL",
-        "TRACK_HABIT",
-        "COMPLETE_TASK",
-        "SET_ALARM",
-        "SET_REMINDER",
-        "SNOOZE_REMINDER",
-        "SET_REMINDER_INTENSITY",
-    ],
-    description: "Manage the user's personal routines, habits, goals, reminders, alarms, and escalation settings through LifeOps. " +
-        "USE this action for: creating, editing, or deleting tasks, habits, routines, and goals; " +
-        "setting one-off alarms or wake-up reminders like 'set an alarm for 7am' or 'wake me up at 7'; " +
-        "helping the user actually set up follow-through when they say things like 'help me brush my teeth every day', 'i keep forgetting x', or 'help me actually do it'; " +
-        "using LifeOps defaults for common routines when the user gives a natural window instead of an exact clock, like water reminders, stretch breaks, weekday-after-lunch Invisalign checks, or brushing when they wake up and before bed; " +
-        "marking items as complete, skipping, or snoozing them; reviewing goal progress; " +
-        "setting up phone/SMS escalation channels; adjusting reminder frequency or intensity; " +
-        "querying an overview of active LifeOps items. " +
-        "ALWAYS use LIFE for dynamic status questions like 'what's still left for today', 'what do i still need to do today', or 'anything else in my LifeOps list', even when the conversation already mentioned tasks, because their status may have changed after a completion, snooze, or reminder. " +
-        "DO NOT use this action for Gmail inbox triage, email search, drafting or sending emails — use GMAIL_ACTION instead. " +
-        "DO NOT use this action for calendar lookups, scheduling meetings, searching events, or travel itineraries — use CALENDAR_ACTION instead. " +
-        "This action provides the final grounded reply; do not pair it with a speculative REPLY action or fall back to advice-only chat when the user wants real LifeOps follow-through.",
-    suppressPostActionContinuation: true,
-    validate: async (runtime, message) => {
-        return hasLifeOpsAccess(runtime, message);
-    },
-    handler: async (runtime, message, state, options) => {
-        if (!(await hasLifeOpsAccess(runtime, message))) {
-            const fallback = "Life management is restricted to the owner, explicitly granted users, and the agent.";
-            return {
-                success: false,
-                text: await renderLifeActionReply({
-                    runtime,
-                    message,
-                    state,
-                    intent: normalizeLifeInputText(messageText(message)),
-                    scenario: "reply_only",
-                    fallback,
-                    context: {
-                        reason: "access_restricted",
-                    },
-                }),
-            };
-        }
-        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
-            : undefined;
-        const draftExpiryReason = deferredLifeDraftExpiryReason({
-            draft: deferredDraft,
-            turnsSinceDraft,
-        });
-        if (draftExpiryReason && looksLikeDeferredLifeConfirmation(currentText)) {
-            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",
-                    },
-                }),
-            };
-        }
-        const deferredDraftFollowupMode = deferredDraft
-            ? await extractDeferredLifeDraftFollowupWithLlm({
-                runtime,
-                message,
-                state,
-                currentText,
-                draft: deferredDraft,
-            })
-            : null;
-        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: "LIFE",
-                    noop: true,
-                },
-            };
-        }
-        const deferredDraftReuseMode = resolveDeferredLifeDraftReuseMode({
-            currentText,
-            details,
-            draft: deferredDraft,
-            explicitAction: params.action,
-            paramsIntent: params.intent,
-            target: params.target,
-            title: params.title,
-            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 explicitOperation = params.action
-            ? ACTION_TO_OPERATION[params.action]
-            : undefined;
-        const operationPlan = reuseDeferredDraft && deferredDraft
-            ? {
-                confidence: 1,
-                missing: [],
-                operation: deferredDraft.operation,
-                shouldAct: true,
-            }
-            : await resolveLifeOperationPlan({
-                runtime,
-                message,
-                state,
-                intent,
-                explicitOperation,
-            });
-        const forceCreateExecution = shouldForceLifeCreateExecution({
-            intent,
-            missing: operationPlan.missing,
-            operation: operationPlan.operation,
-            details,
-            title: params.title,
-        });
-        if (!operationPlan.shouldAct && !forceCreateExecution) {
-            const fallback = buildLifeClarificationFallback({
-                missing: operationPlan.missing,
-                operation: operationPlan.operation,
-            });
-            return {
-                success: true,
-                text: await renderLifeActionReply({
-                    runtime,
-                    message,
-                    state,
-                    intent,
-                    scenario: operationPlan.operation === "create_goal"
-                        ? "clarify_create_goal"
-                        : "clarify_create_definition",
-                    fallback,
-                    context: {
-                        missing: operationPlan.missing,
-                        operation: operationPlan.operation,
-                    },
-                }),
-                data: {
-                    actionName: "LIFE",
-                    noop: true,
-                    suggestedOperation: operationPlan.operation,
-                },
-            };
-        }
-        const operation = (forceCreateExecution ? "create_definition" : operationPlan.operation) ??
-            classifyIntent(intent);
-        const service = new LifeOpsService(runtime);
-        const domain = detailString(details, "domain");
-        const ownership = requestedOwnership(domain);
-        const chatText = intent;
-        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 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 ?? undefined)
-                    : (fallbackCadence ?? explicitCadenceDetail ?? undefined);
-                let windowPolicy = editingDeferredDefinitionDraft
-                    ? (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");
-                // Track whether cadence/title came from explicit high-confidence
-                // sources so the planner only fills genuine gaps.
-                const hadExplicitCadence = Boolean((editingDeferredDefinitionDraft
-                    ? (explicitCadenceDetail ??
-                        deferredDefinitionDraft?.request.cadence)
-                    : deferredDefinitionDraft?.request.cadence) ??
-                    explicitCadenceDetail);
-                const hadExplicitTitle = Boolean((editingDeferredDefinitionDraft
-                    ? params.title
-                    : deferredDefinitionDraft?.request.title) ?? params.title);
-                // ── LLM parameter enhancement (fills gaps) ────────
-                // Skip when reusing a confirmed deferred draft — the user already
-                // approved those values.
-                let llmPlan = null;
-                let llmDescription;
-                let llmPriority;
-                let llmRequestKind = null;
-                if (!deferredDefinitionDraft || editingDeferredDefinitionDraft) {
-                    llmPlan = await extractTaskCreatePlanWithLlm({
-                        runtime,
-                        intent,
-                        state: state ?? undefined,
-                        message: message ?? undefined,
-                    });
-                    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) ?? extractLifeTimeZoneFromText(intent);
-                            const llmCadence = buildCadenceFromLlmParams(llmPlan, {
-                                intent,
-                                timeZone: llmCadenceTimeZone ?? undefined,
-                            });
-                            if (llmCadence &&
-                                shouldAdoptPlannerCadence({
-                                    currentCadence: cadence,
-                                    plannerCadence: llmCadence.cadence,
-                                })) {
-                                cadence = llmCadence.cadence;
-                                windowPolicy = llmCadence.windowPolicy ?? windowPolicy;
-                            }
-                        }
-                        if (!explicitDescription && llmPlan.description) {
-                            llmDescription = llmPlan.description;
-                        }
-                        if (explicitPriority === undefined && llmPlan.priority) {
-                            llmPriority = llmPlan.priority;
-                        }
-                    }
-                }
-                const resolvedTimeZone = normalizeLifeTimeZoneToken(detailString(details, "timeZone") ??
-                    llmPlan?.timeZone ??
-                    deferredDefinitionDraft?.request.timezone ??
-                    windowPolicy?.timezone) ?? extractLifeTimeZoneFromText(intent);
-                const timedRequestKind = llmRequestKind;
-                const nativeAppleMetadata = timedRequestKind && cadence?.kind === "once"
-                    ? buildNativeAppleReminderMetadata({
-                        kind: timedRequestKind,
-                        source: "llm",
-                    })
-                    : undefined;
-                const definitionMetadata = editingDeferredDefinitionDraft
-                    ? mergeMetadataRecords(deferredDefinitionDraft?.request.metadata, mergeMetadataRecords(explicitMetadata, nativeAppleMetadata))
-                    : (deferredDefinitionDraft?.request.metadata ??
-                        mergeMetadataRecords(explicitMetadata, nativeAppleMetadata));
-                if (!title) {
-                    const fallback = "What should I call it?";
-                    return {
-                        success: false,
-                        text: await renderLifeActionReply({
-                            runtime,
-                            message,
-                            state,
-                            intent,
-                            scenario: "clarify_create_definition",
-                            fallback,
-                            context: {
-                                missing: ["title"],
-                                operation: "create_definition",
-                            },
-                        }),
-                    };
-                }
-                if (!cadence) {
-                    const fallback = "When should it happen?";
-                    return {
-                        success: false,
-                        text: await renderLifeActionReply({
-                            runtime,
-                            message,
-                            state,
-                            intent,
-                            scenario: "clarify_create_definition",
-                            fallback,
-                            context: {
-                                missing: ["schedule"],
-                                operation: "create_definition",
-                            },
-                        }),
-                    };
-                }
-                const kind = (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
-                                : undefined),
-                        goalRef: detailString(details, "goalId") ??
-                            detailString(details, "goalTitle") ??
-                            deferredDefinitionDraft?.request.goalRef ??
-                            undefined,
-                        kind,
-                        priority: explicitPriority ??
-                            llmPriority ??
-                            deferredDefinitionDraft?.request.priority,
-                        progressionRule: detailObject(details, "progressionRule") ??
-                            deferredDefinitionDraft?.request.progressionRule,
-                        reminderPlan: detailObject(details, "reminderPlan") ??
-                            deferredDefinitionDraft?.request.reminderPlan ??
-                            buildDefaultReminderPlan(`${title} reminder`),
-                        timezone: extractLifeTimeZoneFromText(intent) ??
-                            normalizeLifeTimeZoneToken(llmPlan?.timeZone) ??
-                            normalizeLifeTimeZoneToken(resolvedTimeZone ?? deferredDefinitionDraft?.request.timezone) ??
-                            resolvedTimeZone ??
-                            deferredDefinitionDraft?.request.timezone,
-                        title,
-                        metadata: definitionMetadata,
-                        windowPolicy,
-                        websiteAccess: detailObject(details, "websiteAccess") ?? deferredDefinitionDraft?.request.websiteAccess,
-                    },
-                };
-                if (shouldRequireLifeCreateConfirmation({
-                    confirmed: createConfirmed,
-                    messageSource: typeof message.content?.source === "string"
-                        ? message.content.source
-                        : undefined,
-                    requestKind: timedRequestKind,
-                    cadence: definitionDraft.request.cadence,
-                })) {
-                    const fallback = `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,
-                            context: {
-                                draft: definitionDraft.request,
-                                requestKind: timedRequestKind,
-                            },
-                        }),
-                        data: {
-                            actionName: "LIFE",
-                            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: extractLifeTimeZoneFromText(definitionDraft.intent) ??
-                        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),
-                };
-            };
-            // ── Queries ─────────────────────────────────────
-            if (operation === "query_calendar_today" ||
-                operation === "query_calendar_next") {
-                const google = await getGoogleCapabilityStatus(service);
-                if (!google.hasCalendarRead) {
-                    return {
-                        success: false,
-                        text: calendarReadUnavailableMessage(google),
-                    };
-                }
-                if (operation === "query_calendar_next") {
-                    const ctx = await service.getNextCalendarEventContext(INTERNAL_URL);
-                    return {
-                        success: true,
-                        text: formatNextEventContext(ctx),
-                        data: toActionData(ctx),
-                    };
-                }
-                const timeRangeHint = intent.toLowerCase();
-                const range = /\btomorrow\b/.test(timeRangeHint)
-                    ? dayRange(1)
-                    : /\b(this week|week)\b/.test(timeRangeHint)
-                        ? weekRange()
-                        : dayRange(0);
-                const label = /\btomorrow\b/.test(timeRangeHint)
-                    ? "tomorrow"
-                    : /\b(this week|week)\b/.test(timeRangeHint)
-                        ? "this week"
-                        : "today";
-                const feed = await service.getCalendarFeed(INTERNAL_URL, {
-                    timeMin: range.timeMin,
-                    timeMax: range.timeMax,
-                });
-                return {
-                    success: true,
-                    text: formatCalendarFeed(feed, label),
-                    data: toActionData(feed),
-                };
-            }
-            if (operation === "query_email") {
-                const limit = detailNumber(details, "limit") ?? 10;
-                return ((await gmailAction.handler?.(runtime, message, state, {
-                    parameters: {
-                        subaction: "triage",
-                        intent,
-                        details: {
-                            ...details,
-                            maxResults: limit,
-                        },
-                    },
-                })) ?? {
-                    success: false,
-                    text: "I couldn't route that Gmail request yet.",
-                });
-            }
-            if (operation === "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),
-                };
-            }
-            // ── Mutations ───────────────────────────────────
-            if (operation === "create_definition") {
-                return await createDefinition();
-            }
-            if (operation === "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 ?? null)
-                    : (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;
-                if (!deferredGoalDraft || editingDeferredGoalDraft) {
-                    const llmPlan = await extractGoalCreatePlanWithLlm({
-                        runtime,
-                        intent,
-                        state: state ?? undefined,
-                        message: message ?? undefined,
-                    });
-                    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: 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?",
-                            data: {
-                                actionName: "LIFE",
-                                noop: true,
-                                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,
-                    },
-                };
-                if (shouldRequireLifeCreateConfirmation({
-                    confirmed: createConfirmed,
-                    messageSource: typeof message.content?.source === "string"
-                        ? message.content.source
-                        : undefined,
-                })) {
-                    const fallback = 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.`;
-                    return {
-                        success: true,
-                        text: await renderLifeActionReply({
-                            runtime,
-                            message,
-                            state,
-                            intent,
-                            scenario: "preview_goal",
-                            fallback,
-                            context: {
-                                draft: goalDraft.request,
-                                groundingSummary: evaluationSummary,
-                            },
-                        }),
-                        data: {
-                            actionName: "LIFE",
-                            deferred: true,
-                            lifeDraft: goalDraft,
-                            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 fallback = `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,
-                            },
-                        },
-                    }),
-                    data: toActionData(created),
-                };
-            }
-            if (operation === "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 : undefined,
-                    description: detailString(details, "description"),
-                    cadence: normalizeCadenceDetail(detailObject(details, "cadence")),
-                    priority: detailNumber(details, "priority"),
-                    windowPolicy: detailObject(details, "windowPolicy"),
-                    reminderPlan: detailObject(details, "reminderPlan"),
-                };
-                // If no explicit changes from structured details, try LLM extraction
-                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 (operation === "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 : undefined,
-                    description: detailString(details, "description"),
-                    cadence: normalizeCadenceDetail(detailObject(details, "cadence")),
-                    supportStrategy: detailObject(details, "supportStrategy"),
-                    successCriteria: detailObject(details, "successCriteria"),
-                };
-                const hasExplicitGoalChanges = request.title !== undefined ||
-                    request.description !== undefined ||
-                    request.cadence !== undefined ||
-                    request.supportStrategy !== undefined ||
-                    request.successCriteria !== undefined;
-                if (!hasExplicitGoalChanges) {
-                    const llmPlan = await extractGoalUpdatePlanWithLlm({
-                        runtime,
-                        currentGoal: target.goal,
-                        intent,
-                        state: state ?? undefined,
-                        message: message ?? undefined,
-                    });
-                    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: "LIFE",
-                                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: 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 === undefined &&
-                    request.description === undefined &&
-                    request.cadence === undefined &&
-                    request.supportStrategy === undefined &&
-                    request.successCriteria === undefined &&
-                    request.metadata === undefined) {
-                    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 (operation === "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 (operation === "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 (operation === "complete_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 — which one?\n${ambiguousCandidates.map((t) => `  - ${t}`).join("\n")}`,
-                        };
-                    }
-                    return {
-                        success: false,
-                        text: "I could not find that active item to complete.",
-                    };
-                }
-                const completed = await service.completeOccurrence(target.id, {
-                    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 (operation === "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 — which one?\n${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 (operation === "snooze_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 — which one?\n${ambiguousCandidates.map((t) => `  - ${t}`).join("\n")}`,
-                        };
-                    }
-                    return {
-                        success: false,
-                        text: "I could not find that active item to snooze.",
-                    };
-                }
-                const preset = detailString(details, "preset");
-                const minutes = detailNumber(details, "minutes");
-                const snoozed = await service.snoozeOccurrence(target.id, {
-                    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 (operation === "review_goal") {
-                const target = await resolveGoal(service, targetName, domain);
-                if (!target)
-                    return {
-                        success: false,
-                        text: "I could not find that goal to review.",
-                    };
-                const review = await service.reviewGoal(target.goal.id);
-                return {
-                    success: true,
-                    text: review.summary.explanation,
-                    data: toActionData(review),
-                };
-            }
-            if (operation === "set_reminder_preference") {
-                const reminderIntensityPlan = await extractReminderIntensityWithLlm({
-                    runtime,
-                    intent,
-                });
-                if (reminderIntensityPlan.intensity === "unknown") {
-                    return {
-                        success: false,
-                        text: "I need to know whether you want reminders minimal, normal, persistent, or high priority only.",
-                    };
-                }
-                const intensity = reminderIntensityPlan.intensity;
-                const target = await resolveDefinitionFromIntent(service, targetName, intent, domain);
-                const request = {
-                    intensity,
-                    definitionId: target?.definition.id ?? null,
-                    note: chatText || intent,
-                };
-                const preference = await service.setReminderPreference(request);
-                if (target) {
-                    const fallback = intensity === "high_priority_only"
-                        ? `Reminder intensity for "${target.definition.title}" is now high priority only.`
-                        : `Reminder intensity for "${target.definition.title}" is now ${describeReminderIntensity(preference.effective.intensity)}.`;
-                    return {
-                        success: true,
-                        text: await renderLifeActionReply({
-                            runtime,
-                            message,
-                            state,
-                            intent,
-                            scenario: "set_reminder_preference",
-                            fallback,
-                            context: {
-                                scope: "definition",
-                                targetTitle: target.definition.title,
-                                intensity: preference.effective.intensity,
-                            },
-                        }),
-                        data: toActionData(preference),
-                    };
-                }
-                const fallback = intensity === "high_priority_only"
-                    ? "Global LifeOps reminders are now high priority only."
-                    : `Global LifeOps reminders are now ${describeReminderIntensity(preference.effective.intensity)}.`;
-                return {
-                    success: true,
-                    text: await renderLifeActionReply({
-                        runtime,
-                        message,
-                        state,
-                        intent,
-                        scenario: "set_reminder_preference",
-                        fallback,
-                        context: {
-                            scope: "global",
-                            intensity: preference.effective.intensity,
-                        },
-                    }),
-                    data: toActionData(preference),
-                };
-            }
-            if (operation === "capture_phone") {
-                const phoneNumber = detailString(details, "phoneNumber") ?? params.title;
-                if (!phoneNumber)
-                    return {
-                        success: false,
-                        text: "I need a phone number to set up SMS or voice contact.",
-                    };
-                const allowSms = detailBoolean(details, "allowSms") ?? true;
-                const allowVoice = detailBoolean(details, "allowVoice") ?? false;
-                const result = await service.capturePhoneConsent({
-                    phoneNumber,
-                    consentGiven: true,
-                    allowSms,
-                    allowVoice,
-                    privacyClass: "private",
-                });
-                const channels = [];
-                if (allowSms)
-                    channels.push("SMS");
-                if (allowVoice)
-                    channels.push("voice calls");
-                const fallback = `Phone number ${result.phoneNumber} saved. Enabled for: ${channels.join(" and ") || "reminders"}.`;
-                return {
-                    success: true,
-                    text: await renderLifeActionReply({
-                        runtime,
-                        message,
-                        state,
-                        intent,
-                        scenario: "captured_phone",
-                        fallback,
-                        context: {
-                            phoneNumber: result.phoneNumber,
-                            channels,
-                        },
-                    }),
-                    data: toActionData(result),
-                };
-            }
-            if (operation === "configure_escalation") {
-                const target = await resolveDefinition(service, targetName, domain);
-                if (!target)
-                    return {
-                        success: false,
-                        text: "I could not find that item to configure its reminders.",
-                    };
-                const rawSteps = detailArray(details, "steps") ??
-                    detailArray(details, "escalationSteps");
-                const steps = rawSteps
-                    ? rawSteps
-                        .filter((s) => typeof s === "object" && s !== null)
-                        .map((s) => ({
-                        channel: String(s.channel ?? "in_app"),
-                        offsetMinutes: typeof s.offsetMinutes === "number" ? s.offsetMinutes : 0,
-                        label: typeof s.label === "string"
-                            ? s.label
-                            : String(s.channel ?? "reminder"),
-                    }))
-                    : [{ channel: "in_app", offsetMinutes: 0, label: "In-app reminder" }];
-                const updated = await service.updateDefinition(target.definition.id, {
-                    ownership,
-                    reminderPlan: { steps },
-                });
-                const summary = steps
-                    .map((s) => `${s.channel} at +${s.offsetMinutes}m`)
-                    .join(", ");
-                const fallback = `Updated reminder plan for "${updated.definition.title}": ${summary}.`;
-                return {
-                    success: true,
-                    text: await renderLifeActionReply({
-                        runtime,
-                        message,
-                        state,
-                        intent,
-                        scenario: "configured_escalation",
-                        fallback,
-                        context: {
-                            targetTitle: updated.definition.title,
-                            steps,
-                        },
-                    }),
-                    data: toActionData(updated),
-                };
-            }
-            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;
-        }
-    },
-    parameters: [
-        {
-            name: "action",
-            description: "What kind of life operation to perform.",
-            required: false,
-            schema: {
-                type: "string",
-                enum: [
-                    "create",
-                    "create_goal",
-                    "update",
-                    "update_goal",
-                    "delete",
-                    "delete_goal",
-                    "complete",
-                    "skip",
-                    "snooze",
-                    "review",
-                    "phone",
-                    "escalation",
-                    "reminder_preference",
-                    "calendar",
-                    "next_event",
-                    "email",
-                    "overview",
-                ],
-            },
-        },
-        {
-            name: "intent",
-            description: 'Natural language description of what to do. Examples: "create a daily brushing habit for morning and night", "snooze brushing for 30 minutes", "what\'s on my calendar today".',
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "title",
-            description: "Name for a new item, or the name of an existing item to act on.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "target",
-            description: "Name or ID of an existing item when different from title (e.g., when renaming).",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "details",
-            description: "Structured data when needed. May include: cadence (schedule object), kind (task/habit/routine), description, priority, progressionRule, reminderPlan, confirmed (boolean when the user explicitly approves a previewed create), preset (snooze preset like 15m/30m/1h/tonight/tomorrow_morning), minutes (snooze minutes), phoneNumber, allowSms, allowVoice, steps (escalation steps array), goalId, goalTitle, supportStrategy, successCriteria, note, limit, domain (user_lifeops/agent_ops), or reminder preference targeting.",
-            required: false,
-            schema: { type: "object" },
-        },
-    ],
-    examples: [
-        [
-            {
-                name: "{{name1}}",
-                content: {
-                    text: "help me remember to drink water",
-                },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: 'I can set up a "Drink water" habit with a reasonable daytime default cadence. Confirm and I\'ll save it.',
-                    actions: ["LIFE"],
-                },
-            },
-        ],
-        [
-            {
-                name: "{{name1}}",
-                content: {
-                    text: "help me remember to stretch during the day",
-                },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: 'I can set up a "Stretch" habit with daytime stretch-break defaults. Confirm and I\'ll save it.',
-                    actions: ["LIFE"],
-                },
-            },
-        ],
-        [
-            {
-                name: "{{name1}}",
-                content: {
-                    text: "please remind me about my Invisalign on weekdays after lunch",
-                },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "I can set up a weekday-after-lunch Invisalign habit. Confirm and I'll save it.",
-                    actions: ["LIFE"],
-                },
-            },
-        ],
-        [
-            {
-                name: "{{name1}}",
-                content: {
-                    text: "recuérdame cepillarme los dientes por la mañana y por la noche",
-                },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: 'Puedo guardar el hábito "Brush teeth" para la mañana y la noche. Confirma y lo guardo.',
-                    actions: ["LIFE"],
-                },
-            },
-        ],
-        [
-            {
-                name: "{{name1}}",
-                content: {
-                    text: "help me brush my teeth at 8 am and 9 pm every day",
-                },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: 'I can set up a habit named "Brush teeth" for 8 am and 9 pm daily. Confirm and I\'ll save it.',
-                    actions: ["LIFE"],
-                },
-            },
-        ],
-        [
-            {
-                name: "{{name1}}",
-                content: {
-                    text: "what life ops tasks are still left for today?",
-                },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "You have 2 LifeOps tasks left for today: call mom and pay rent.",
-                    actions: ["LIFE"],
-                },
-            },
-            {
-                name: "{{name1}}",
-                content: {
-                    text: "anything else in my life ops list i need to get done today?",
-                },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "You have 1 LifeOps task left for today: pay rent.",
-                    actions: ["LIFE"],
-                },
-            },
-        ],
-        [
-            {
-                name: "{{name1}}",
-                content: {
-                    text: "remind me less about brush teeth",
-                },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: 'Reminder intensity for "Brush teeth" is now minimal.',
-                    actions: ["LIFE"],
-                },
-            },
-        ],
-    ],
-};
+export * from "@elizaos/app-lifeops/actions/life";