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

package/dist/activity-profile/proactive-worker.js

@@ -0,0 +1,779 @@
+import {
+  getAgentEventService,
+  loadElizaConfig,
+  loadOwnerContactsConfig,
+  resolveOwnerContactWithFallback
+} from "@elizaos/agent";
+import {
+  logger,
+  ModelType,
+  parseJsonModelRecord,
+  runWithTrajectoryContext,
+  stringToUuid
+} from "@elizaos/core";
+import { loadLifeOpsAppState } from "../lifeops/app-state.js";
+import {
+  BackgroundPlannerError,
+  planJob
+} from "../lifeops/background-planner.js";
+import { enqueueIfSensitive } from "../lifeops/background-planner-dispatch.js";
+import { resolveDefaultTimeZone } from "../lifeops/defaults.js";
+import { ensureRuntimeAgentRecord } from "../lifeops/runtime.js";
+import { LifeOpsService, LifeOpsServiceError } from "../lifeops/service.js";
+import { resolveEffectiveDayKey } from "./analyzer.js";
+import { proactiveInboxDigestRequest } from "./proactive-inbox-digest.js";
+import {
+  planDowntimeNudges,
+  planGm,
+  planGn,
+  planGoalCheckIns,
+  planNudges,
+  planSocialOveruseCheck,
+  SOCIAL_OVERUSE_WINDOW_MINUTES
+} from "./proactive-planner.js";
+import {
+  buildActivityProfile,
+  profileNeedsRebuild,
+  readFiredLogFromMetadata,
+  readProfileFromMetadata,
+  refreshCurrentState,
+  resolveOwnerEntityId
+} from "./service.js";
+const PROACTIVE_TASK_NAME = "PROACTIVE_AGENT";
+const PROACTIVE_TASK_TAGS = ["queue", "repeat", "proactive"];
+const PROACTIVE_TASK_INTERVAL_MS = 6e4;
+const CALENDAR_PROACTIVE_CLASSIFICATION_HORIZON_DAYS = 21;
+const STALE_ACTION_THRESHOLD_MS = 4 * 60 * 60 * 1e3;
+function isAppFirstRunComplete() {
+  try {
+    return loadElizaConfig().meta?.firstRunComplete === true;
+  } catch {
+    return false;
+  }
+}
+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 /* @__PURE__ */ 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 normalizePlannerBoolean(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (["true", "yes", "1"].includes(normalized)) {
+      return true;
+    }
+    if (["false", "no", "0"].includes(normalized)) {
+      return false;
+    }
+  }
+  return null;
+}
+function formatPromptScalar(value, maxLength = 600) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  return String(value).replace(/\s+/g, " ").trim().slice(0, maxLength);
+}
+function formatCalendarEventsForPrompt(events) {
+  return events.map(
+    (event, index) => [
+      `events[${index}]:`,
+      `  id: ${formatPromptScalar(event.id, 200)}`,
+      `  summary: ${formatPromptScalar(event.summary, 300)}`,
+      `  description: ${formatPromptScalar(event.description ?? "", 500)}`,
+      `  location: ${formatPromptScalar(event.location ?? "", 300)}`,
+      `  startAt: ${formatPromptScalar(event.startAt, 80)}`,
+      `  endAt: ${formatPromptScalar(event.endAt, 80)}`,
+      `  isAllDay: ${event.isAllDay}`,
+      `  attendeeCount: ${event.attendeeCount ?? 0}`,
+      `  hasConferenceLink: ${Boolean(event.conferenceLink)}`
+    ].join("\n")
+  ).join("\n");
+}
+function normalizeCalendarEventProactiveDecisions(parsed, allowedIds) {
+  const records = Array.isArray(parsed?.events) ? parsed.events : Array.isArray(parsed?.decisions) ? parsed.decisions : Array.isArray(parsed) ? parsed : [];
+  const decisions = /* @__PURE__ */ 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;
+    }
+    const shouldCheckIn = normalizePlannerBoolean(
+      record.shouldCheckIn ?? record.should_check_in
+    );
+    decisions.set(id, {
+      id,
+      shouldCheckIn: shouldCheckIn === true,
+      reason: typeof record.reason === "string" && record.reason.trim().length > 0 ? record.reason.trim() : null
+    });
+  }
+  return decisions;
+}
+function parseCalendarEventProactiveOutput(raw) {
+  return parseJsonModelRecord(raw);
+}
+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 * 1e3;
+  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 /* @__PURE__ */ 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 JSON only, for example {"events":[{"id":"matching event id","shouldCheckIn":true,"reason":"short reason"}]}.',
+    "No prose, markdown, code fences, or <think>.",
+    "",
+    `Current timezone: ${timezone}`,
+    `Current ISO datetime: ${now.toISOString()}`,
+    "Events:",
+    formatCalendarEventsForPrompt(candidateEvents)
+  ].join("\n");
+  try {
+    const result = await runWithTrajectoryContext(
+      { purpose: "lifeops-proactive-worker" },
+      () => runtime.useModel(ModelType.TEXT_LARGE, { prompt })
+    );
+    const raw = typeof result === "string" ? result : "";
+    const parsed = parseCalendarEventProactiveOutput(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 : void 0
+      },
+      `[proactive] Failed to classify proactive calendar events: ${String(error)}`
+    );
+    return null;
+  }
+}
+function resolveProactiveDeliverySource(targetPlatform) {
+  if (targetPlatform === "web_app" || targetPlatform === "desktop_app" || targetPlatform === "mobile_app" || targetPlatform === "macos_activity_collector") {
+    return "client_chat";
+  }
+  return targetPlatform;
+}
+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;
+}
+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 };
+  }
+  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 \u2014 ${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);
+  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 socialSummary = await loadSocialOveruseSummary(runtime, now);
+  const socialOveruseAction = socialSummary ? planSocialOveruseCheck(profile, socialSummary, firedLog, timezone, now) : null;
+  const allActions = [
+    hydratedGmAction,
+    hydratedGnAction,
+    ...nudgeActions,
+    ...downtimeActions,
+    ...goalCheckInActions,
+    socialOveruseAction
+  ].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;
+    }
+    const ageMs = now.getTime() - action.scheduledFor;
+    if (ageMs > STALE_ACTION_THRESHOLD_MS) {
+      logger.warn(
+        `[proactive] Skipping stale ${action.kind} (scheduledFor was ${Math.round(ageMs / 6e4)} 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);
+          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);
+      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 };
+}
+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 : void 0
+      },
+      `[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 } : void 0,
+        priority: occ.priority
+      });
+    }
+  } catch (error) {
+    logger.warn(
+      {
+        boundary: "activity_profile",
+        operation: "planner_overview",
+        err: error instanceof Error ? error : void 0
+      },
+      `[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 : void 0
+      },
+      `[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 : void 0
+      },
+      `[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(
+      proactiveInboxDigestRequest()
+    );
+    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 : void 0
+      },
+      `[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 ?? []],
+    seedingOfferedAt: log?.seedingOfferedAt,
+    socialOveruseCheckedAt: log?.socialOveruseCheckedAt
+  };
+  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 === "social_overuse_check") {
+    current.socialOveruseCheckedAt = Date.now();
+  }
+  return current;
+}
+async function loadSocialOveruseSummary(runtime, now) {
+  const sinceMs = now.getTime() - SOCIAL_OVERUSE_WINDOW_MINUTES * 6e4;
+  const since = new Date(sinceMs).toISOString();
+  const until = now.toISOString();
+  try {
+    const summary = await new LifeOpsService(runtime).getSocialHabitSummary({
+      since,
+      until
+    });
+    return {
+      totalSeconds: summary.totalSeconds,
+      services: summary.services.map((entry) => ({
+        key: entry.key,
+        label: entry.label,
+        totalSeconds: entry.totalSeconds
+      }))
+    };
+  } catch (error) {
+    logger.warn(
+      {
+        boundary: "activity_profile",
+        operation: "planner_social_overuse_summary",
+        err: error instanceof Error ? error : void 0
+      },
+      `[proactive] Failed to read social-habit summary for overuse planner: ${String(error)}`
+    );
+    return null;
+  }
+}
+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 === "social_overuse_check") {
+    return "proactive-social-overuse";
+  }
+  return "proactive-nudge";
+}
+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 {
+        if (!isAppFirstRunComplete()) return false;
+        if (!rt.getModel(ModelType.TEXT_SMALL)) return false;
+        const state = await loadLifeOpsAppState(rt);
+        return state.enabled;
+      } catch (error) {
+        logger.warn(
+          `[proactive-worker] proactive tick preflight failed; skipping because runtime readiness is unknown: ${error instanceof Error ? error.message : String(error)}`
+        );
+        return false;
+      }
+    },
+    execute: (rt, options) => executeProactiveTask(rt, isRecord(options) ? options : {})
+  });
+}
+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()
+  });
+}
+export {
+  PROACTIVE_TASK_INTERVAL_MS,
+  PROACTIVE_TASK_NAME,
+  PROACTIVE_TASK_TAGS,
+  classifyCalendarEventsForProactivePlanning,
+  ensureProactiveAgentTask,
+  executeProactiveTask,
+  isAppFirstRunComplete,
+  registerProactiveTaskWorker,
+  resolveProactiveDeliverySource,
+  resolveProactiveOwnerContact
+};
+//# sourceMappingURL=proactive-worker.js.map