@elizaos/ui 2.0.0-alpha.382 → 2.0.0-alpha.385

package/apps/app-lifeops/src/activity-profile/proactive-worker.js

@@ -1,676 +0,0 @@
-import { logger, ModelType, parseJSONObjectFromText, stringToUuid, } from "@elizaos/core";
-import { getAgentEventService, loadOwnerContactsConfig, resolveOwnerContactWithFallback, } from "@elizaos/agent";
-import { loadLifeOpsAppState } from "../lifeops/app-state.js";
-import { ensureRuntimeAgentRecord } from "../lifeops/runtime.js";
-import { resolveDefaultTimeZone } from "../lifeops/defaults.js";
-import { LifeOpsService, LifeOpsServiceError } from "../lifeops/service.js";
-import { BackgroundPlannerError, planJob, } from "../lifeops/background-planner.js";
-import { enqueueIfSensitive } from "../lifeops/background-planner-dispatch.js";
-import { resolveEffectiveDayKey } from "./analyzer.js";
-import { planDowntimeNudges, planGm, planGn, planGoalCheckIns, planNudges, } from "./proactive-planner.js";
-import { buildActivityProfile, profileNeedsRebuild, readFiredLogFromMetadata, readProfileFromMetadata, refreshCurrentState, resolveOwnerEntityId, } from "./service.js";
-export const PROACTIVE_TASK_NAME = "PROACTIVE_AGENT";
-export const PROACTIVE_TASK_TAGS = ["queue", "repeat", "proactive"];
-export const PROACTIVE_TASK_INTERVAL_MS = 60_000;
-const SEEDING_MIN_IDLE_MS = 15 * 60_000;
-const CALENDAR_PROACTIVE_CLASSIFICATION_HORIZON_DAYS = 21;
-/**
- * Drop scheduled actions that were due more than this long ago. Without
- * this guard, any planner bug that lands `scheduledFor` in the past
- * would dispatch on every tick of the worker (60s).
- */
-const STALE_ACTION_THRESHOLD_MS = 4 * 60 * 60 * 1000;
-function isRecord(value) {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function resolveExecutionNow(options = {}) {
-    const raw = options.now;
-    if (raw instanceof Date) {
-        return new Date(raw.getTime());
-    }
-    if (typeof raw === "number" && Number.isFinite(raw)) {
-        return new Date(raw);
-    }
-    if (typeof raw === "string" && raw.trim().length > 0) {
-        const parsed = new Date(raw);
-        if (Number.isFinite(parsed.getTime())) {
-            return parsed;
-        }
-    }
-    return new Date();
-}
-function isProactiveTask(task) {
-    const metadata = isRecord(task.metadata) ? task.metadata : null;
-    const agent = metadata?.proactiveAgent;
-    return (task.name === PROACTIVE_TASK_NAME &&
-        isRecord(agent) &&
-        agent.kind === "runtime_runner");
-}
-function buildProactiveMetadata(current = null) {
-    return {
-        ...(current ?? {}),
-        updateInterval: PROACTIVE_TASK_INTERVAL_MS,
-        baseInterval: PROACTIVE_TASK_INTERVAL_MS,
-        blocking: true,
-        proactiveAgent: {
-            kind: "runtime_runner",
-            version: 1,
-        },
-    };
-}
-function normalizeCalendarEventProactiveDecisions(parsed, allowedIds) {
-    const records = Array.isArray(parsed?.events)
-        ? parsed.events
-        : Array.isArray(parsed?.decisions)
-            ? parsed.decisions
-            : Array.isArray(parsed)
-                ? parsed
-                : [];
-    const decisions = new Map();
-    for (const item of records) {
-        if (!item || typeof item !== "object" || Array.isArray(item)) {
-            continue;
-        }
-        const record = item;
-        const id = typeof record.id === "string" && record.id.trim().length > 0
-            ? record.id.trim()
-            : null;
-        if (!id || !allowedIds.has(id)) {
-            continue;
-        }
-        decisions.set(id, {
-            id,
-            shouldCheckIn: record.shouldCheckIn === true,
-            reason: typeof record.reason === "string" && record.reason.trim().length > 0
-                ? record.reason.trim()
-                : null,
-        });
-    }
-    return decisions;
-}
-export async function classifyCalendarEventsForProactivePlanning(runtime, events, timezone, now) {
-    if (typeof runtime.useModel !== "function") {
-        return null;
-    }
-    const horizonMs = now.getTime() +
-        CALENDAR_PROACTIVE_CLASSIFICATION_HORIZON_DAYS * 24 * 60 * 60 * 1000;
-    const candidateEvents = events
-        .filter((event) => {
-        const startMs = Date.parse(event.startAt);
-        return (Number.isFinite(startMs) &&
-            startMs >= now.getTime() &&
-            startMs <= horizonMs);
-    })
-        .sort((left, right) => Date.parse(left.startAt) - Date.parse(right.startAt))
-        .slice(0, 40);
-    if (candidateEvents.length === 0) {
-        return new Map();
-    }
-    const prompt = [
-        "Decide which calendar events deserve a proactive check-in or reminder from the assistant.",
-        "Do not use fixed numeric weights. Judge naturally from the event details.",
-        "A proactive check-in should be reserved for events where a gentle heads-up would actually help.",
-        "Meetings, calls, interviews, appointments, therapy, coffee or dinner with people, and other short scheduled social/professional events usually deserve a check-in.",
-        "Hotel stays, flights, travel blocks, reservations, check-in/check-out, passive itinerary items, and long all-day or near-all-day logistics usually do not deserve a check-in.",
-        "If an event would be extremely hard to forget or has no clear actionability, mark shouldCheckIn=false.",
-        'Return only valid JSON with this shape: {"events":[{"id":"...","shouldCheckIn":true|false,"reason":"short reason"}]}',
-        "",
-        `Current timezone: ${timezone}`,
-        `Current ISO datetime: ${now.toISOString()}`,
-        "Events:",
-        JSON.stringify(candidateEvents.map((event) => ({
-            id: event.id,
-            summary: event.summary,
-            description: event.description ?? "",
-            location: event.location ?? "",
-            startAt: event.startAt,
-            endAt: event.endAt,
-            isAllDay: event.isAllDay,
-            attendeeCount: event.attendeeCount ?? 0,
-            hasConferenceLink: Boolean(event.conferenceLink),
-        }))),
-    ].join("\n");
-    try {
-        const result = await runtime.useModel(ModelType.TEXT_LARGE, { prompt });
-        const raw = typeof result === "string" ? result : "";
-        const parsed = parseJSONObjectFromText(raw);
-        if (!parsed) {
-            return null;
-        }
-        return normalizeCalendarEventProactiveDecisions(parsed, new Set(candidateEvents.map((event) => event.id)));
-    }
-    catch (error) {
-        logger.warn({
-            boundary: "activity_profile",
-            operation: "planner_calendar_event_classification",
-            err: error instanceof Error ? error : undefined,
-        }, `[proactive] Failed to classify proactive calendar events: ${String(error)}`);
-        return null;
-    }
-}
-export function resolveProactiveDeliverySource(targetPlatform) {
-    if (targetPlatform === "web_app" ||
-        targetPlatform === "desktop_app" ||
-        targetPlatform === "mobile_app") {
-        return "client_chat";
-    }
-    return targetPlatform;
-}
-export function resolveProactiveOwnerContact(args) {
-    const deliverySource = resolveProactiveDeliverySource(args.targetPlatform);
-    if (deliverySource === "client_chat") {
-        return {
-            source: "client_chat",
-            contact: { entityId: args.ownerEntityId },
-        };
-    }
-    const resolved = resolveOwnerContactWithFallback({
-        ownerContacts: args.ownerContacts,
-        source: deliverySource,
-        ownerEntityId: args.ownerEntityId,
-    });
-    if (resolved) {
-        return {
-            source: resolved.source,
-            contact: resolved.contact,
-        };
-    }
-    return null;
-}
-export async function executeProactiveTask(runtime, options = {}) {
-    const now = resolveExecutionNow(options);
-    const timezone = resolveDefaultTimeZone();
-    const ownerEntityId = await resolveOwnerEntityId(runtime);
-    if (!ownerEntityId) {
-        return { nextInterval: PROACTIVE_TASK_INTERVAL_MS };
-    }
-    // WS5: Route this tick through the shared LLM planner. The planner
-    // decides whether any action is warranted and whether it requires
-    // human approval. We invoke it up-front so every proactive tick is
-    // observable via `planJob` and so sensitive actions are always
-    // enqueued into the WS6 approval queue.
-    const plannerContext = {
-        jobKind: "daily_brief",
-        subjectUserId: ownerEntityId,
-        snapshot: {
-            now: now.toISOString(),
-            timezone,
-        },
-        availableChannels: ["internal"],
-        trigger: "proactive_tick",
-    };
-    try {
-        const plan = await planJob(runtime, plannerContext);
-        await enqueueIfSensitive(runtime, plannerContext, plan);
-    }
-    catch (error) {
-        if (error instanceof BackgroundPlannerError) {
-            logger.warn(`[proactive] background planner unavailable — ${error.message}`);
-        }
-        else {
-            throw error;
-        }
-    }
-    const tasks = await runtime.getTasks({
-        agentIds: [runtime.agentId],
-        tags: [...PROACTIVE_TASK_TAGS],
-    });
-    const task = tasks.find(isProactiveTask);
-    if (!task?.id) {
-        return { nextInterval: PROACTIVE_TASK_INTERVAL_MS };
-    }
-    const metadata = isRecord(task.metadata) ? task.metadata : {};
-    const currentProfile = readProfileFromMetadata(metadata);
-    let profile;
-    if (profileNeedsRebuild(currentProfile, now)) {
-        logger.info("[proactive] Building full activity profile");
-        profile = await buildActivityProfile(runtime, ownerEntityId, timezone, now);
-    }
-    else if (currentProfile) {
-        profile = await refreshCurrentState(runtime, ownerEntityId, currentProfile, now);
-    }
-    else {
-        profile = null;
-    }
-    if (!profile) {
-        return { nextInterval: PROACTIVE_TASK_INTERVAL_MS };
-    }
-    const todayStr = resolveEffectiveDayKey(profile, timezone, now);
-    let firedLog = readFiredLogFromMetadata(metadata, todayStr);
-    let inboxDigest = null;
-    const { occurrences, calendarEvents, goals, relativeTime } = await fetchPlannerContext(runtime, timezone, now);
-    // NOTE: planGm/planGn apply their own time-of-day gating today; the
-    // canonical source of truth for morning/night enforcement windows is
-    // `src/lifeops/enforcement-windows.ts` (getCurrentEnforcementWindow).
-    // If planner gating is ever consolidated, switch these helpers to use
-    // that utility so the reminder pipeline and the proactive worker agree.
-    const gmAction = planGm(profile, occurrences, calendarEvents, relativeTime, null, firedLog, timezone, now);
-    const gnAction = planGn(profile, relativeTime, null, firedLog, timezone, now);
-    if (isDigestActionReady(gmAction, now) ||
-        isDigestActionReady(gnAction, now)) {
-        inboxDigest = await loadInboxDigest(runtime);
-    }
-    const hydratedGmAction = planGm(profile, occurrences, calendarEvents, relativeTime, inboxDigest, firedLog, timezone, now);
-    const hydratedGnAction = planGn(profile, relativeTime, inboxDigest, firedLog, timezone, now);
-    const nudgeActions = planNudges(profile, occurrences, calendarEvents, firedLog, timezone, now);
-    const downtimeActions = planDowntimeNudges(profile, occurrences, calendarEvents, firedLog, timezone, now);
-    const goalCheckInActions = planGoalCheckIns(profile, goals, firedLog, timezone, now);
-    const seedingAction = await planSeedingOffer(runtime, profile, firedLog, now);
-    const allActions = [
-        seedingAction,
-        hydratedGmAction,
-        hydratedGnAction,
-        ...nudgeActions,
-        ...downtimeActions,
-        ...goalCheckInActions,
-    ].filter((action) => action !== null && action.status === "pending");
-    const ownerContacts = loadOwnerContactsConfig({
-        boundary: "activity_profile",
-        operation: "owner_contacts_config",
-        message: "[proactive] Failed to load owner contacts config; proactive messages cannot route to owner channels until config is available.",
-    });
-    for (const action of allActions) {
-        if (action.scheduledFor > now.getTime()) {
-            continue;
-        }
-        // Defensive: don't dispatch stale actions (e.g. a GN whose target
-        // hour resolved to the past). Without this guard a single planner
-        // miscomputation will fire every PROACTIVE_TASK_INTERVAL_MS.
-        const ageMs = now.getTime() - action.scheduledFor;
-        if (ageMs > STALE_ACTION_THRESHOLD_MS) {
-            logger.warn(`[proactive] Skipping stale ${action.kind} (scheduledFor was ${Math.round(ageMs / 60000)} min ago)`);
-            continue;
-        }
-        const resolvedTarget = resolveProactiveOwnerContact({
-            targetPlatform: action.targetPlatform,
-            ownerEntityId,
-            ownerContacts,
-        });
-        const contact = resolvedTarget?.contact;
-        if (!resolvedTarget || !contact) {
-            logger.warn(`[proactive] No owner contact for platform ${action.targetPlatform}, skipping ${action.kind}`);
-            continue;
-        }
-        if (!contact.entityId && !contact.channelId && !contact.roomId) {
-            logger.warn(`[proactive] No owner contact for platform ${action.targetPlatform}, skipping ${action.kind}`);
-            continue;
-        }
-        try {
-            if (resolvedTarget.source === "client_chat") {
-                if (emitProactiveAssistantEvent(runtime, action)) {
-                    firedLog = recordFiredAction(firedLog, todayStr, action);
-                    if (action.kind === "onboarding_seed") {
-                        try {
-                            await new LifeOpsService(runtime).markSeedingOffered();
-                        }
-                        catch (err) {
-                            logger.warn(`[proactive] Failed to record onboarding seed offer audit: ${err}`);
-                        }
-                    }
-                    logger.info(`[proactive] Emitted ${action.kind} as assistant event`);
-                    continue;
-                }
-                logger.warn(`[proactive] AGENT_EVENT emit unavailable for ${action.kind}; skipping in-app proactive delivery`);
-                continue;
-            }
-            await runtime.sendMessageToTarget({
-                source: resolvedTarget.source,
-                entityId: contact.entityId,
-                channelId: contact.channelId,
-                roomId: contact.roomId,
-            }, buildProactiveDeliveryContent(action, resolvedTarget.source));
-            firedLog = recordFiredAction(firedLog, todayStr, action);
-            if (action.kind === "onboarding_seed") {
-                try {
-                    await new LifeOpsService(runtime).markSeedingOffered();
-                }
-                catch (err) {
-                    logger.warn(`[proactive] Failed to record onboarding seed offer audit: ${err}`);
-                }
-            }
-            logger.info(`[proactive] Fired ${action.kind} on ${resolvedTarget.source}`);
-        }
-        catch (err) {
-            logger.warn(`[proactive] Failed to send ${action.kind}: ${err}`);
-        }
-    }
-    await runtime.updateTask(task.id, {
-        metadata: {
-            ...metadata,
-            activityProfile: profile,
-            firedActionsLog: firedLog,
-        },
-    });
-    return { nextInterval: PROACTIVE_TASK_INTERVAL_MS };
-}
-const SEEDING_MESSAGE = "I notice you haven't set up any routines yet. Want me to set up some " +
-    "foundational habits? I can add: brush teeth, drink water, stretch breaks, " +
-    "vitamins, workout, shower, and shave reminders. Say 'set up my routines' " +
-    "or pick and choose.";
-async function planSeedingOffer(runtime, profile, firedLog, now) {
-    // Only offer seeding once per day at most
-    if (firedLog?.seedingOfferedAt) {
-        return null;
-    }
-    if (profile.isCurrentlyActive ||
-        now.getTime() - profile.lastSeenAt < SEEDING_MIN_IDLE_MS) {
-        return null;
-    }
-    try {
-        const service = new LifeOpsService(runtime);
-        const result = await service.checkAndOfferSeeding();
-        if (!result.needsSeeding) {
-            return null;
-        }
-    }
-    catch (error) {
-        logger.warn(`[proactive] Failed to check seeding status: ${error}`);
-        return null;
-    }
-    return {
-        kind: "onboarding_seed",
-        scheduledFor: now.getTime(),
-        targetPlatform: profile.primaryPlatform ?? "web_app",
-        contextSummary: "No routines configured; offering seed templates",
-        messageText: SEEDING_MESSAGE,
-        status: "pending",
-    };
-}
-async function fetchPlannerContext(runtime, timezone, now) {
-    const occurrences = [];
-    const calendarEvents = [];
-    const goals = [];
-    let relativeTime = null;
-    const lifeOpsService = new LifeOpsService(runtime);
-    try {
-        const schedule = await lifeOpsService.getScheduleMergedState({
-            timezone,
-            scope: "effective",
-            refresh: true,
-            now,
-        });
-        relativeTime = schedule?.relativeTime
-            ? {
-                wakeAnchorAt: schedule.relativeTime.wakeAnchorAt,
-                bedtimeTargetAt: schedule.relativeTime.bedtimeTargetAt,
-                minutesSinceWake: schedule.relativeTime.minutesSinceWake,
-                minutesUntilBedtimeTarget: schedule.relativeTime.minutesUntilBedtimeTarget,
-            }
-            : null;
-    }
-    catch (error) {
-        logger.warn({
-            boundary: "activity_profile",
-            operation: "planner_schedule_state",
-            err: error instanceof Error ? error : undefined,
-        }, `[proactive] Failed to read schedule context for proactive planning: ${String(error)}`);
-    }
-    try {
-        const overview = await lifeOpsService.getOverview(now);
-        for (const occ of overview.occurrences) {
-            occurrences.push({
-                id: occ.id,
-                title: occ.title ?? occ.definitionId ?? "untitled",
-                dueAt: occ.dueAt,
-                state: occ.state,
-                definitionKind: occ.definitionKind,
-                cadence: occ.cadence ? { kind: occ.cadence.kind } : undefined,
-                priority: occ.priority,
-            });
-        }
-    }
-    catch (error) {
-        logger.warn({
-            boundary: "activity_profile",
-            operation: "planner_overview",
-            err: error instanceof Error ? error : undefined,
-        }, `[proactive] Failed to read LifeOps overview for planner context: ${String(error)}`);
-    }
-    try {
-        const feed = await lifeOpsService.getCalendarFeed(new URL("http://localhost/api/lifeops/calendar"), {}, now);
-        const rawCalendarEvents = feed.events.map((event) => ({
-            id: event.id,
-            summary: event.title ?? "",
-            startAt: event.startAt,
-            endAt: event.endAt,
-            isAllDay: event.isAllDay,
-            description: event.description ?? "",
-            location: event.location ?? "",
-            attendeeCount: Array.isArray(event.attendees)
-                ? event.attendees.length
-                : 0,
-            conferenceLink: event.conferenceLink ?? null,
-        }));
-        const decisions = await classifyCalendarEventsForProactivePlanning(runtime, rawCalendarEvents, timezone, now);
-        for (const event of feed.events) {
-            const decision = decisions?.get(event.id) ?? null;
-            calendarEvents.push({
-                id: event.id,
-                summary: event.title ?? "",
-                startAt: event.startAt,
-                endAt: event.endAt,
-                isAllDay: event.isAllDay,
-                description: event.description ?? "",
-                location: event.location ?? "",
-                attendeeCount: Array.isArray(event.attendees)
-                    ? event.attendees.length
-                    : 0,
-                conferenceLink: event.conferenceLink ?? null,
-                proactiveCheckIn: decision?.shouldCheckIn ?? null,
-                proactiveCheckInReason: decision?.reason ?? null,
-            });
-        }
-    }
-    catch (error) {
-        if (error instanceof LifeOpsServiceError && error.status === 409) {
-            return { occurrences, calendarEvents, goals, relativeTime };
-        }
-        logger.warn({
-            boundary: "activity_profile",
-            operation: "planner_calendar_feed",
-            err: error instanceof Error ? error : undefined,
-        }, `[proactive] Failed to read calendar context for proactive planning: ${String(error)}`);
-    }
-    try {
-        const goalRecords = await lifeOpsService.listGoals();
-        for (const record of goalRecords) {
-            if (record.goal.status !== "active")
-                continue;
-            const review = await lifeOpsService.reviewGoal(record.goal.id, now);
-            const scheduled = review.summary.activeOccurrenceCount +
-                review.summary.overdueOccurrenceCount +
-                review.summary.completedLast7Days;
-            goals.push({
-                id: record.goal.id,
-                title: record.goal.title,
-                status: record.goal.status,
-                linkedDefinitionCount: review.summary.linkedDefinitionCount,
-                recentCompletionRate: scheduled > 0 ? review.summary.completedLast7Days / scheduled : 0,
-                lastReviewedAt: review.summary.lastActivityAt,
-            });
-        }
-    }
-    catch (error) {
-        logger.warn({
-            boundary: "activity_profile",
-            operation: "planner_goals",
-            err: error instanceof Error ? error : undefined,
-        }, `[proactive] Failed to read goal context for proactive planning: ${String(error)}`);
-    }
-    return { occurrences, calendarEvents, goals, relativeTime };
-}
-function isDigestActionReady(action, now) {
-    return Boolean(action &&
-        (action.kind === "gm" || action.kind === "gn") &&
-        action.status === "pending" &&
-        action.scheduledFor <= now.getTime());
-}
-async function loadInboxDigest(runtime) {
-    try {
-        const inbox = await new LifeOpsService(runtime).getInbox({ limit: 24 });
-        const unreadCount = Object.values(inbox.channelCounts).reduce((sum, count) => sum + count.unread, 0);
-        const channelCounts = Object.entries(inbox.channelCounts)
-            .map(([channel, count]) => ({
-            channel,
-            unreadCount: count.unread,
-        }))
-            .filter((entry) => entry.unreadCount > 0)
-            .sort((left, right) => right.unreadCount - left.unreadCount);
-        const highlights = [...inbox.messages]
-            .sort((left, right) => {
-            const unreadDelta = Number(right.unread) - Number(left.unread);
-            if (unreadDelta !== 0) {
-                return unreadDelta;
-            }
-            return Date.parse(right.receivedAt) - Date.parse(left.receivedAt);
-        })
-            .slice(0, 3)
-            .map((message) => ({
-            channel: message.channel,
-            sender: message.sender.displayName,
-            subject: message.subject,
-            snippet: message.snippet,
-            receivedAt: message.receivedAt,
-            unread: message.unread,
-        }));
-        return {
-            unreadCount,
-            channelCounts,
-            highlights,
-        };
-    }
-    catch (error) {
-        logger.warn({
-            boundary: "activity_profile",
-            operation: "planner_inbox",
-            err: error instanceof Error ? error : undefined,
-        }, `[proactive] Failed to read inbox for proactive digest: ${String(error)}`);
-        return null;
-    }
-}
-function recordFiredAction(log, todayStr, action) {
-    const current = {
-        date: log?.date ?? todayStr,
-        gmFiredAt: log?.gmFiredAt,
-        gnFiredAt: log?.gnFiredAt,
-        nudgedOccurrenceIds: [...(log?.nudgedOccurrenceIds ?? [])],
-        nudgedCalendarEventIds: [...(log?.nudgedCalendarEventIds ?? [])],
-        checkedGoalIds: [...(log?.checkedGoalIds ?? [])],
-    };
-    if (action.kind === "gm") {
-        current.gmFiredAt = Date.now();
-    }
-    else if (action.kind === "gn") {
-        current.gnFiredAt = Date.now();
-    }
-    else if (action.kind === "pre_activity_nudge") {
-        if (action.occurrenceId &&
-            !current.nudgedOccurrenceIds.includes(action.occurrenceId)) {
-            current.nudgedOccurrenceIds.push(action.occurrenceId);
-        }
-        if (action.calendarEventId &&
-            !current.nudgedCalendarEventIds.includes(action.calendarEventId)) {
-            current.nudgedCalendarEventIds.push(action.calendarEventId);
-        }
-    }
-    else if (action.kind === "goal_check_in") {
-        if (action.goalId && !current.checkedGoalIds?.includes(action.goalId)) {
-            current.checkedGoalIds?.push(action.goalId);
-        }
-    }
-    else if (action.kind === "onboarding_seed") {
-        current.seedingOfferedAt = Date.now();
-    }
-    return current;
-}
-function buildProactiveDeliveryContent(action, deliverySource) {
-    const text = action.messageText.trim() || action.contextSummary.trim();
-    return { text, source: deliverySource };
-}
-function emitProactiveAssistantEvent(runtime, action) {
-    const eventService = getAgentEventService(runtime);
-    if (!eventService?.emit) {
-        return false;
-    }
-    const text = action.messageText.trim() || action.contextSummary.trim();
-    eventService.emit({
-        runId: crypto.randomUUID(),
-        stream: "assistant",
-        agentId: runtime.agentId,
-        data: {
-            text,
-            source: resolveProactiveAssistantEventSource(action),
-            kind: action.kind,
-            scheduledFor: action.scheduledFor,
-            targetPlatform: action.targetPlatform,
-            occurrenceId: action.occurrenceId,
-            calendarEventId: action.calendarEventId,
-            goalId: action.goalId,
-        },
-    });
-    return true;
-}
-function resolveProactiveAssistantEventSource(action) {
-    if (action.kind === "gm") {
-        return "proactive-gm";
-    }
-    if (action.kind === "gn") {
-        return "proactive-gn";
-    }
-    if (action.kind === "goal_check_in") {
-        return "proactive-goal-check-in";
-    }
-    if (action.kind === "onboarding_seed") {
-        return "proactive-onboarding";
-    }
-    return "proactive-nudge";
-}
-export function registerProactiveTaskWorker(runtime) {
-    if (runtime.getTaskWorker(PROACTIVE_TASK_NAME)) {
-        return;
-    }
-    runtime.registerTaskWorker({
-        name: PROACTIVE_TASK_NAME,
-        // Skip execution when the user has disabled LifeOps via the UI. The task
-        // record and worker stay registered so toggling back on requires no
-        // restart — cycles just become cheap no-ops while disabled.
-        shouldRun: async (rt) => {
-            try {
-                const state = await loadLifeOpsAppState(rt);
-                return state.enabled;
-            }
-            catch (error) {
-                logger.warn(`[proactive-worker] loadLifeOpsAppState failed; skipping proactive tick because LifeOps toggle state is unknown: ${error instanceof Error ? error.message : String(error)}`);
-                return false;
-            }
-        },
-        execute: (rt, options) => executeProactiveTask(rt, isRecord(options) ? options : {}),
-    });
-}
-export async function ensureProactiveAgentTask(runtime) {
-    await ensureRuntimeAgentRecord(runtime);
-    const tasks = await runtime.getTasks({
-        agentIds: [runtime.agentId],
-        tags: [...PROACTIVE_TASK_TAGS],
-    });
-    const existing = tasks.find(isProactiveTask);
-    const metadata = buildProactiveMetadata(isRecord(existing?.metadata) ? existing.metadata : null);
-    if (existing?.id) {
-        await runtime.updateTask(existing.id, {
-            description: "Proactive agent: GM/GN/nudges based on activity profile",
-            metadata,
-        });
-        return existing.id;
-    }
-    const autonomy = runtime.getService("AUTONOMY");
-    const roomId = autonomy?.getAutonomousRoomId?.() ??
-        stringToUuid(`proactive-agent-room-${runtime.agentId}`);
-    return runtime.createTask({
-        name: PROACTIVE_TASK_NAME,
-        description: "Proactive agent: GM/GN/nudges based on activity profile",
-        roomId,
-        tags: [...PROACTIVE_TASK_TAGS],
-        metadata,
-        dueAt: Date.now(),
-    });
-}

package/apps/app-lifeops/src/activity-profile/service.d.ts

@@ -1,11 +0,0 @@
-import type { IAgentRuntime } from "@elizaos/core";
-import { LifeOpsScreenContextSampler } from "../lifeops/screen-context.js";
-export { resolveOwnerEntityId, } from "@elizaos/agent";
-import type { ActivityProfile, FiredActionsLog } from "./types.js";
-export declare function setScreenContextSamplerForTesting(sampler: LifeOpsScreenContextSampler | null): void;
-export declare function buildActivityProfile(runtime: IAgentRuntime, ownerEntityId: string, timezone?: string, now?: Date): Promise<ActivityProfile>;
-export declare function refreshCurrentState(runtime: IAgentRuntime, ownerEntityId: string, profile: ActivityProfile, now?: Date): Promise<ActivityProfile>;
-export { readProfileFromMetadata } from "./profile-metadata.js";
-export declare function readFiredLogFromMetadata(metadata: Record<string, unknown> | null, todayDateStr: string): FiredActionsLog | null;
-export declare function profileNeedsRebuild(profile: ActivityProfile | null, now: Date): boolean;
-//# sourceMappingURL=service.d.ts.map

package/apps/app-lifeops/src/activity-profile/service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/activity-profile/service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAQ,MAAM,eAAe,CAAC;AAGzD,OAAO,EACL,2BAA2B,EAE5B,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EACL,oBAAoB,GACrB,MAAM,gBAAgB,CAAC;AAUxB,OAAO,KAAK,EACV,eAAe,EAEf,eAAe,EAChB,MAAM,YAAY,CAAC;AAiBpB,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,2BAA2B,GAAG,IAAI,GAC1C,IAAI,CAEN;AAqFD,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,aAAa,EACtB,aAAa,EAAE,MAAM,EACrB,QAAQ,CAAC,EAAE,MAAM,EACjB,GAAG,CAAC,EAAE,IAAI,GACT,OAAO,CAAC,eAAe,CAAC,CAsF1B;AAID,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,aAAa,EACtB,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,eAAe,EACxB,GAAG,CAAC,EAAE,IAAI,GACT,OAAO,CAAC,eAAe,CAAC,CAgF1B;AAMD,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,EACxC,YAAY,EAAE,MAAM,GACnB,eAAe,GAAG,IAAI,CAyBxB;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,eAAe,GAAG,IAAI,EAC/B,GAAG,EAAE,IAAI,GACR,OAAO,CAGT"}