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

package/dist/plugin.js

@@ -0,0 +1,989 @@
+import {
+  EventType,
+  getDefaultTriageService,
+  logger,
+  messagingTriageActions,
+  promoteSubactionsToActions,
+  registerLocalizedExamplesProvider,
+  registerSendPolicy
+} from "@elizaos/core";
+import { BrowserBridgeAdapter } from "@elizaos/plugin-browser";
+import { calendarPlugin } from "@elizaos/plugin-calendar";
+import { CalendlyAdapter } from "@elizaos/plugin-calendly";
+import { financesPlugin } from "@elizaos/plugin-finances/plugin";
+import { goalsPlugin } from "@elizaos/plugin-goals/plugin";
+import { GoogleGmailAdapter } from "@elizaos/plugin-google";
+import {
+  createDefaultCircadianInsightContract,
+  healthPlugin,
+  registerCircadianInsightContract,
+  registerHealthAnchors,
+  registerHealthBusFamilies,
+  registerHealthConnectors,
+  registerHealthDefaultPacks
+} from "@elizaos/plugin-health";
+import { inboxPlugin } from "@elizaos/plugin-inbox/plugin";
+import { remindersPlugin } from "@elizaos/plugin-reminders";
+import { remoteDesktopPlugin } from "@elizaos/plugin-remote-desktop";
+import { XDmAdapter } from "@elizaos/plugin-x/lifeops-message-adapter";
+import { blockAction } from "./actions/block.js";
+import { briefAction } from "./actions/brief.js";
+import { calendarAction } from "./actions/calendar.js";
+import { conflictDetectAction } from "./actions/conflict-detect.js";
+import { connectorAction } from "./actions/connector.js";
+import { credentialsAction } from "./actions/credentials.js";
+import { ownerDocumentsAction } from "./actions/document.js";
+import { entityAction } from "./actions/entity.js";
+import { inboxAction } from "./actions/inbox.js";
+import {
+  ownerAlarmsAction,
+  ownerFinancesAction,
+  ownerGoalsAction,
+  ownerHealthAction,
+  ownerRemindersAction,
+  ownerRoutinesAction,
+  ownerScreenTimeAction,
+  ownerTodosAction,
+  personalAssistantAction
+} from "./actions/owner-surfaces.js";
+import { prioritizeAction } from "./actions/prioritize.js";
+import { resolveRequestAction } from "./actions/resolve-request.js";
+import { scheduledTaskAction } from "./actions/scheduled-task.js";
+import { voiceCallAction } from "./actions/voice-call.js";
+import { workThreadAction } from "./actions/work-thread.js";
+import { ActivityTrackerService } from "./activity-profile/activity-tracker-service.js";
+import { PresenceSignalBridgeService } from "./activity-profile/presence-signal-bridge-service.js";
+import {
+  ensureProactiveAgentTask,
+  isAppFirstRunComplete,
+  PROACTIVE_TASK_NAME,
+  registerProactiveTaskWorker
+} from "./activity-profile/proactive-worker.js";
+import {
+  ensureFollowupTrackerTask,
+  FOLLOWUP_TRACKER_TASK_NAME,
+  registerFollowupTrackerWorker
+} from "./followup/index.js";
+import { InboxTriageRepository } from "./inbox/repository.js";
+import { createApprovalQueue } from "./lifeops/approval-queue.js";
+import { registerLifeOpsCalendarGate } from "./lifeops/calendar-gate.js";
+import {
+  createChannelRegistry,
+  registerChannelRegistry,
+  registerDefaultChannelPack
+} from "./lifeops/channels/index.js";
+import {
+  createConnectorRegistry,
+  registerConnectorRegistry,
+  registerDefaultConnectorPack
+} from "./lifeops/connectors/index.js";
+import { applyMockoonEnvOverrides } from "./lifeops/connectors/mockoon-redirect.js";
+import { handleVoiceTurnObserved } from "./lifeops/entities/voice-observer-bridge.js";
+import { createOwnerLocaleExamplesProvider } from "./lifeops/i18n/localized-examples-provider.js";
+import {
+  createMultilingualPromptRegistry,
+  registerDefaultPromptPack,
+  registerMultilingualPromptRegistry
+} from "./lifeops/i18n/prompt-registry.js";
+import { createOwnerSendPolicy } from "./lifeops/messaging/owner-send-policy.js";
+import {
+  createOwnerFactStore,
+  registerOwnerFactStore
+} from "./lifeops/owner/fact-store.js";
+import { ownerProfileExtractionEvaluator } from "./lifeops/owner/profile-extraction-evaluator.js";
+import {
+  createAnchorRegistry,
+  createEventKindRegistry,
+  createFamilyRegistry,
+  createWorkflowStepRegistry,
+  registerAnchorRegistry,
+  registerAppLifeOpsAnchors,
+  registerAppLifeOpsBusFamilies,
+  registerAppLifeOpsEventKinds,
+  registerBuiltinTelemetryFamilies,
+  registerDefaultBlockerPack,
+  registerDefaultFeatureFlagPack,
+  registerDefaultWorkflowStepPack,
+  registerEventKindRegistry,
+  registerFamilyRegistry,
+  registerWorkflowStepRegistry
+} from "./lifeops/registries/index.js";
+import { LifeOpsRepository } from "./lifeops/repository.js";
+import {
+  ensureLifeOpsSchedulerTask,
+  LIFEOPS_TASK_NAME,
+  registerLifeOpsTaskWorker
+} from "./lifeops/runtime.js";
+import { ScheduledTaskRunnerService } from "./lifeops/scheduled-task/service.js";
+import { lifeOpsSchema } from "./lifeops/schema.js";
+import {
+  createSendPolicyRegistry,
+  registerSendPolicyRegistry
+} from "./lifeops/send-policy/index.js";
+import {
+  createActivitySignalBus,
+  registerActivitySignalBus
+} from "./lifeops/signals/bus.js";
+import { threadOpsFieldEvaluator } from "./lifeops/work-threads/field-evaluator-thread-ops.js";
+import { isDarwin } from "./platform/host.js";
+import { browserBridgeProvider } from "./provider.js";
+import { activityProfileProvider } from "./providers/activity-profile.js";
+import { crossChannelContextProvider } from "./providers/cross-channel-context.js";
+import { firstRunProvider } from "./providers/first-run.js";
+import { healthProvider } from "./providers/health.js";
+import { inboxTriageProvider } from "./providers/inbox-triage.js";
+import { lifeOpsProvider } from "./providers/lifeops.js";
+import { pendingPromptsProvider } from "./providers/pending-prompts.js";
+import { recentTaskStatesProvider } from "./providers/recent-task-states.js";
+import { roomPolicyProvider } from "./providers/room-policy.js";
+import { workThreadsProvider } from "./providers/work-threads.js";
+import { BrowserBridgePluginService } from "./service.js";
+import { registerBlockRuleReconcilerWorker } from "./website-blocker/chat-integration/index.js";
+const GOOGLE_CONNECTOR_PLUGIN_PACKAGE = "@elizaos/plugin-google";
+const GOOGLE_CONNECTOR_PLUGIN_NAME = "google";
+function getMessageText(message) {
+  return typeof message.content.text === "string" ? message.content.text : "";
+}
+function looksLikeMissedCallRepairApproval(text) {
+  const normalized = text.toLowerCase();
+  return /\bmissed\b/.test(normalized) && /\bcall\b/.test(normalized) && /\b(?:repair|reschedul|follow\s*up|reply|respond)\b/.test(normalized) && /\b(?:approval|approve|hold|confirm)\b/.test(normalized);
+}
+function looksLikeFlightConflictQuestion(text) {
+  const normalized = text.toLowerCase();
+  return /\b(?:flight|flights?|airport|jfk|sfo|lax|ewr|lga)\b/u.test(normalized) && /\b(?:meeting|board|calendar|appointment|event)\b/u.test(normalized) && /\b(?:land|lands|arrival|arrive|make|conflict|rebook)\b/u.test(normalized);
+}
+function looksLikeDocumentSignatureRequest(text) {
+  const normalized = text.toLowerCase();
+  return /\b(?:nda|docusign|signature|signed|signing|sign\s+(?:the|a)?\s*(?:document|doc|nda)|document\s+sign(?:ing|ature)?)\b/u.test(
+    normalized
+  ) && /\b(?:meeting|appointment|kick-?off|deadline|before|due|in\s+\d+\s+days?|partnership)\b/u.test(
+    normalized
+  ) && /\b(?:initiate|start|begin|draft|queue|prepare|send|get\s+(?:it|the\s+nda)\s+signed|signing\s+flow)\b/u.test(
+    normalized
+  );
+}
+function looksLikePortalUploadRequest(text) {
+  const normalized = text.toLowerCase();
+  return /\b(?:upload|submit|send|file)\b/u.test(normalized) && /\bportal\b/u.test(normalized) && /\b(?:deck|slides?|presentation|pdf|file)\b/u.test(normalized);
+}
+function buildPortalUploadIntakeResponse() {
+  return {
+    text: "I need the portal link and the deck file or file path before I can upload it. Once you provide both, I will ask for approval to confirm before signing in or submitting anything.",
+    success: true,
+    data: {
+      actionName: "COMPUTER_USE",
+      operation: "portal_upload_intake",
+      requiredInputs: ["portal_link", "deck_file"],
+      requiresConfirmation: true
+    }
+  };
+}
+function defaultSignatureDeadline(text) {
+  const match = /\bin\s+(\d+)\s+days?\b/iu.exec(text);
+  if (match?.[1]) {
+    return new Date(
+      Date.now() + Number(match[1]) * 24 * 60 * 60 * 1e3
+    ).toISOString();
+  }
+  return new Date(Date.now() + 48 * 60 * 60 * 1e3).toISOString();
+}
+async function queueDocumentSignatureRequest(args) {
+  const text = getMessageText(args.message);
+  const documentName = /\bnda\b/iu.test(text) ? "NDA" : "Document";
+  const documentId = `signature-${String(args.message.id ?? Date.now())}`;
+  const signatureUrl = text.match(/https?:\/\/\S+/u)?.[0] ?? "pending-signature-url";
+  const subjectUserId = typeof args.message.entityId === "string" ? args.message.entityId : String(args.runtime.agentId);
+  const queue = createApprovalQueue(args.runtime, {
+    agentId: args.runtime.agentId
+  });
+  const request = await queue.enqueue({
+    requestedBy: "PERSONAL_ASSISTANT",
+    subjectUserId,
+    action: "sign_document",
+    payload: {
+      action: "sign_document",
+      documentId,
+      documentName,
+      signatureUrl,
+      deadline: defaultSignatureDeadline(text)
+    },
+    channel: "internal",
+    reason: `Initiate signing flow for ${documentName}`,
+    expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1e3)
+  });
+  const responseText = `Queued the ${documentName} signing flow for approval before anything is sent.`;
+  await args.callback?.({
+    text: responseText,
+    source: "action",
+    action: "PERSONAL_ASSISTANT"
+  });
+  return {
+    success: true,
+    text: responseText,
+    data: {
+      actionName: "PERSONAL_ASSISTANT",
+      action: "sign_document",
+      approvalRequestId: request.id
+    }
+  };
+}
+function buildFlightConflictPreview(text) {
+  if (/8\s*(?:am|a\.m\.)/iu.test(text) && /9\s*(?:am|a\.m\.)/iu.test(text)) {
+    return "The 8 AM JFK arrival is too tight for a 9 AM board meeting. I would treat that as a conflict unless the meeting is at the airport or remote. The concrete options are to rebook to an earlier flight or the night before, move the meeting later, or plan to join remotely while in transit.";
+  }
+  return "Your 8 AM JFK arrival is too tight for the 9 AM board meeting on that calendar day. I would treat it as a conflict and propose one of these concrete options: rebook to an arrival no later than 6:30 AM, fly in the night before, move the board meeting to 10:30 AM or later, or join remotely while in transit.";
+}
+function approvalChannelFromSource(source) {
+  const normalized = (source ?? "").toLowerCase();
+  if (normalized === "discord") return "discord";
+  if (normalized === "imessage") return "imessage";
+  if (normalized === "sms" || normalized === "text") return "sms";
+  if (normalized === "x" || normalized === "twitter" || normalized === "x_dm") {
+    return "x_dm";
+  }
+  return "telegram";
+}
+function extractCounterpartyHint(text) {
+  const match = /\bwith\s+(?:the\s+)?(.+?)(?:\s+(?:guys|team|folks|people)\b|[,.]|$)/iu.exec(
+    text
+  ) ?? /\b(?:to|for)\s+([A-Z][\w &'-]{2,80})(?:[,.]|$)/u.exec(text);
+  return match?.[1]?.replace(/\s+/gu, " ").trim() || null;
+}
+function textMatchesEntry(text, entryText) {
+  const normalized = text.toLowerCase();
+  const candidate = entryText.toLowerCase();
+  return candidate.split(/\s+/u).map((token) => token.replace(/[^a-z0-9]/gu, "")).filter((token) => token.length >= 4).some((token) => normalized.includes(token));
+}
+async function handleLifeOpsMessageAction(args) {
+  if (args.operation !== "triage" && args.operation !== "send_draft" && args.operation !== "draft_followup" && args.operation !== "draft_reply" && args.operation !== "respond") {
+    return null;
+  }
+  const text = getMessageText(args.message);
+  if (!looksLikeMissedCallRepairApproval(text)) {
+    return null;
+  }
+  const triageRepo = new InboxTriageRepository(args.runtime);
+  const unresolved = await triageRepo.getUnresolved({ limit: 25 });
+  const hint = extractCounterpartyHint(text);
+  const match = unresolved.find((entry) => {
+    const haystack = [
+      entry.channelName,
+      entry.senderName ?? "",
+      entry.snippet,
+      entry.suggestedResponse ?? "",
+      ...entry.threadContext ?? []
+    ].join(" ");
+    return (hint ? haystack.toLowerCase().includes(hint.toLowerCase()) : false) || textMatchesEntry(text, haystack);
+  }) ?? unresolved[0];
+  const recipient = match?.sourceRoomId ?? match?.sourceEntityId ?? match?.channelName;
+  const body = match?.suggestedResponse ?? (hint ? `Sorry I missed your call earlier. I can reschedule and make the walkthrough work this week if you send a couple of windows.` : `Sorry I missed your call earlier. I can reschedule this week if you send a couple of windows that work.`);
+  const channel = approvalChannelFromSource(match?.source);
+  const subjectUserId = typeof args.message.entityId === "string" ? args.message.entityId : String(args.runtime.agentId);
+  const queue = createApprovalQueue(args.runtime, {
+    agentId: args.runtime.agentId
+  });
+  const request = await queue.enqueue({
+    requestedBy: "MESSAGE",
+    subjectUserId,
+    action: "send_message",
+    payload: {
+      action: "send_message",
+      recipient,
+      body,
+      replyToMessageId: match?.sourceMessageId ?? null
+    },
+    channel,
+    reason: `Repair missed call thread${match?.channelName ? ` with ${match.channelName}` : hint ? ` with ${hint}` : ""}`,
+    expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1e3)
+  });
+  const responseText = `Queued the repair note for your approval before sending it.`;
+  await args.callback?.({
+    text: responseText,
+    source: "action",
+    action: "MESSAGE"
+  });
+  return {
+    text: responseText,
+    success: true,
+    data: {
+      actionName: "MESSAGE",
+      operation: args.operation,
+      requestId: request.id,
+      requiresConfirmation: true,
+      channel,
+      recipient
+    }
+  };
+}
+async function handleLifeOpsDirectMessageRequest(args) {
+  const text = getMessageText(args.message);
+  if (looksLikeMissedCallRepairApproval(text)) {
+    return handleLifeOpsMessageAction({
+      operation: "triage",
+      runtime: args.runtime,
+      message: args.message,
+      state: args.state
+    });
+  }
+  if (looksLikeFlightConflictQuestion(text)) {
+    return {
+      text: buildFlightConflictPreview(text),
+      success: true,
+      data: {
+        actionName: "CALENDAR",
+        subaction: "flight_conflict_rebooking"
+      }
+    };
+  }
+  if (looksLikeDocumentSignatureRequest(text)) {
+    return queueDocumentSignatureRequest(args);
+  }
+  if (looksLikePortalUploadRequest(text)) {
+    return buildPortalUploadIntakeResponse();
+  }
+  return null;
+}
+async function ensureTaskWithRetries(args) {
+  const isRuntimeStopped = () => args.runtime.stopped === true;
+  const delays = args.delays ?? [2e3, 5e3, 1e4];
+  for (let attempt = 0; attempt <= delays.length; attempt += 1) {
+    if (isRuntimeStopped()) {
+      return;
+    }
+    try {
+      await args.ensure();
+      return;
+    } catch (error) {
+      if (isRuntimeStopped()) {
+        return;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      if (attempt < delays.length) {
+        args.runtime.logger.warn(
+          `${args.prefix} ${args.label} init failed (attempt ${attempt + 1}/${delays.length + 1}), retrying in ${delays[attempt]}ms: ${message}`
+        );
+        await new Promise((resolve) => setTimeout(resolve, delays[attempt]));
+        continue;
+      }
+      args.runtime.logger.error(
+        `${args.prefix} ${args.label} init failed after ${delays.length + 1} attempts: ${message}`
+      );
+      throw error instanceof Error ? error : new Error(`${args.label} init failed: ${message}`);
+    }
+  }
+}
+function isDisabledByEnv(disableKey) {
+  const disableValue = (process.env[disableKey] ?? "").trim().toLowerCase();
+  if (disableValue === "1" || disableValue === "true" || disableValue === "yes") {
+    return true;
+  }
+  return false;
+}
+function isGoogleConnectorPlugin(plugin) {
+  return plugin.name === GOOGLE_CONNECTOR_PLUGIN_NAME || plugin.name === GOOGLE_CONNECTOR_PLUGIN_PACKAGE;
+}
+function resolvePluginExport(module) {
+  for (const key of ["googlePlugin", "default"]) {
+    const value = module[key];
+    if (value && typeof value === "object" && typeof value.name === "string") {
+      return value;
+    }
+  }
+  return null;
+}
+async function importGoogleConnectorPluginModule() {
+  try {
+    return await import(GOOGLE_CONNECTOR_PLUGIN_PACKAGE);
+  } catch (error) {
+    const stagedDependencyUrl = new URL(
+      "../node_modules/@elizaos/plugin-google/dist/index.js",
+      import.meta.url
+    );
+    try {
+      return await import(stagedDependencyUrl.href);
+    } catch {
+      throw error;
+    }
+  }
+}
+async function ensureLifeOpsGooglePluginRegistered(runtime) {
+  if (runtime.plugins.some(isGoogleConnectorPlugin)) {
+    return;
+  }
+  const module = await importGoogleConnectorPluginModule();
+  const plugin = resolvePluginExport(module);
+  if (!plugin) {
+    throw new Error(
+      `${GOOGLE_CONNECTOR_PLUGIN_PACKAGE} did not export a valid plugin`
+    );
+  }
+  if (runtime.plugins.some(isGoogleConnectorPlugin)) {
+    return;
+  }
+  await runtime.registerPlugin(plugin);
+}
+async function ensureLifeOpsCalendarPluginRegistered(runtime) {
+  if (runtime.plugins.some((plugin) => plugin.name === calendarPlugin.name)) {
+    return;
+  }
+  await runtime.registerPlugin({
+    ...calendarPlugin,
+    actions: []
+  });
+}
+async function ensureLifeOpsFinancesPluginRegistered(runtime) {
+  if (runtime.plugins.some((plugin) => plugin.name === financesPlugin.name)) {
+    return;
+  }
+  await runtime.registerPlugin(financesPlugin);
+}
+async function ensureLifeOpsRemindersPluginRegistered(runtime) {
+  if (runtime.plugins.some((plugin) => plugin.name === remindersPlugin.name)) {
+    return;
+  }
+  await runtime.registerPlugin(remindersPlugin);
+}
+async function ensureLifeOpsInboxPluginRegistered(runtime) {
+  if (runtime.plugins.some((plugin) => plugin.name === inboxPlugin.name)) {
+    return;
+  }
+  await runtime.registerPlugin(inboxPlugin);
+}
+async function ensureLifeOpsRemoteDesktopPluginRegistered(runtime) {
+  if (runtime.plugins.some((plugin) => plugin.name === remoteDesktopPlugin.name)) {
+    return;
+  }
+  await runtime.registerPlugin(remoteDesktopPlugin);
+}
+async function ensureLifeOpsGoalsPluginRegistered(runtime) {
+  if (runtime.plugins.some((plugin) => plugin.name === goalsPlugin.name)) {
+    return;
+  }
+  await runtime.registerPlugin({
+    ...goalsPlugin,
+    actions: []
+  });
+}
+async function ensureLifeOpsHealthPluginRegistered(runtime) {
+  if (!runtime.plugins.some((plugin) => plugin.name === healthPlugin.name)) {
+    await runtime.registerPlugin(healthPlugin);
+  }
+  registerHealthConnectors(runtime);
+  registerHealthAnchors(runtime);
+  registerHealthBusFamilies(runtime);
+  registerHealthDefaultPacks(runtime);
+  registerCircadianInsightContract(
+    runtime,
+    createDefaultCircadianInsightContract()
+  );
+}
+const LIFEOPS_TASK_INIT_FAILURE_CACHE_KEY = "eliza:lifeops:plugin:init-failures";
+async function recordTaskInitFailure(runtime, label, message) {
+  try {
+    const existing = await runtime.getCache(
+      LIFEOPS_TASK_INIT_FAILURE_CACHE_KEY
+    ) ?? {};
+    existing[label] = message;
+    await runtime.setCache(LIFEOPS_TASK_INIT_FAILURE_CACHE_KEY, existing);
+  } catch {
+  }
+}
+const platformGatedActionUmbrellas = isDarwin() ? [ownerScreenTimeAction] : [];
+function scheduleTaskEnsureAfterRuntimeInit(args) {
+  void args.runtime.initPromise.then(async () => {
+    if (args.runtime.stopped === true) {
+      return;
+    }
+    await ensureTaskWithRetries(args);
+  }).catch((error) => {
+    if (args.runtime.stopped === true) {
+      return;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    args.runtime.logger.error(
+      `${args.prefix} ${args.label} init failed after runtime initialization (plugin stays loaded, this subsystem is degraded): ${message}`
+    );
+    void recordTaskInitFailure(args.runtime, args.label, message);
+  });
+}
+const rawPersonalAssistantPlugin = {
+  name: "@elizaos/plugin-personal-assistant",
+  description: "Personal assistant workspace: executive workflows, owner approvals, scheduled tasks, calendar, inbox, documents, reminders, money admin, and focused owner-operation views.",
+  dependencies: [GOOGLE_CONNECTOR_PLUGIN_PACKAGE],
+  schema: lifeOpsSchema,
+  actions: [
+    // Canonical owner-operation umbrellas. Each umbrella registers itself + its
+    // per-action virtuals via
+    // `promoteSubactionsToActions` so the planner sees a discoverable
+    // top-level entry for every flat child action (e.g. `BLOCK_BLOCK`,
+    // `BLOCK_LIST_ACTIVE`, `OWNER_FINANCES_DASHBOARD`, `CREDENTIALS_FILL`, ...).
+    ...promoteSubactionsToActions(blockAction),
+    ...promoteSubactionsToActions(ownerFinancesAction),
+    ...promoteSubactionsToActions(credentialsAction),
+    ...promoteSubactionsToActions(calendarAction),
+    ...promoteSubactionsToActions(resolveRequestAction),
+    ...promoteSubactionsToActions(ownerRemindersAction),
+    ...promoteSubactionsToActions(ownerAlarmsAction),
+    ...promoteSubactionsToActions(ownerGoalsAction),
+    ...promoteSubactionsToActions(ownerTodosAction),
+    ...promoteSubactionsToActions(ownerRoutinesAction),
+    ...promoteSubactionsToActions(ownerHealthAction),
+    ...platformGatedActionUmbrellas.flatMap(
+      (action) => promoteSubactionsToActions(action)
+    ),
+    ...promoteSubactionsToActions(personalAssistantAction),
+    entityAction,
+    ...promoteSubactionsToActions(ownerDocumentsAction),
+    ...promoteSubactionsToActions(briefAction),
+    ...promoteSubactionsToActions(prioritizeAction),
+    ...promoteSubactionsToActions(conflictDetectAction),
+    ...promoteSubactionsToActions(inboxAction),
+    ...promoteSubactionsToActions(voiceCallAction),
+    workThreadAction,
+    ...promoteSubactionsToActions(scheduledTaskAction),
+    ...promoteSubactionsToActions(connectorAction),
+    ...messagingTriageActions
+  ],
+  providers: [
+    browserBridgeProvider,
+    firstRunProvider,
+    roomPolicyProvider,
+    lifeOpsProvider,
+    pendingPromptsProvider,
+    workThreadsProvider,
+    recentTaskStatesProvider,
+    healthProvider,
+    inboxTriageProvider,
+    crossChannelContextProvider,
+    activityProfileProvider
+  ],
+  services: [
+    BrowserBridgePluginService,
+    ActivityTrackerService,
+    PresenceSignalBridgeService,
+    ScheduledTaskRunnerService
+  ],
+  responseHandlerEvaluators: [ownerProfileExtractionEvaluator],
+  responseHandlerFieldEvaluators: [threadOpsFieldEvaluator],
+  // No views — the LifeOps overview surface was removed (owner: "no need for an
+  // overview"). Domain views live in the per-domain plugins; the personal
+  // assistant is the chat itself (PERSONAL_ASSISTANT action).
+  events: {
+    // Fold recognized voice turns into the entity/relationship graph via
+    // the merge engine, then round-trip the binding to the voice-profile
+    // owner. See lifeops/entities/voice-observer-bridge.ts.
+    [EventType.VOICE_TURN_OBSERVED]: [handleVoiceTurnObserved]
+  },
+  init: async (_pluginConfig, runtime) => {
+    const mockoonApplied = applyMockoonEnvOverrides();
+    if (mockoonApplied.length > 0) {
+      logger.info(
+        { mockoonConnectors: mockoonApplied },
+        `[lifeops] LIFEOPS_USE_MOCKOON=1 \u2014 redirecting ${mockoonApplied.length} connector base URL(s) to mock servers`
+      );
+    }
+    await ensureLifeOpsGooglePluginRegistered(runtime);
+    await ensureLifeOpsCalendarPluginRegistered(runtime);
+    await ensureLifeOpsFinancesPluginRegistered(runtime);
+    await ensureLifeOpsRemindersPluginRegistered(runtime);
+    await ensureLifeOpsGoalsPluginRegistered(runtime);
+    await ensureLifeOpsInboxPluginRegistered(runtime);
+    await ensureLifeOpsRemoteDesktopPluginRegistered(runtime);
+    void runtime.initPromise.then(() => {
+      if (runtime.stopped === true) {
+        return;
+      }
+      registerLifeOpsCalendarGate(runtime);
+    }).catch((error) => {
+      logger.error(
+        `[lifeops] failed to register calendar host gate (calendar degraded to default gate): ${error instanceof Error ? error.message : String(error)}`
+      );
+    });
+    const connectorRegistry = createConnectorRegistry();
+    registerDefaultConnectorPack(connectorRegistry, runtime);
+    registerConnectorRegistry(runtime, connectorRegistry);
+    runtime.connectorRegistry = connectorRegistry;
+    const channelRegistry = createChannelRegistry();
+    registerDefaultChannelPack(channelRegistry, runtime);
+    registerChannelRegistry(runtime, channelRegistry);
+    runtime.channelRegistry = channelRegistry;
+    const sendPolicyRegistry = createSendPolicyRegistry();
+    registerSendPolicyRegistry(runtime, sendPolicyRegistry);
+    registerDefaultBlockerPack(runtime);
+    const anchorRegistry = createAnchorRegistry();
+    registerAppLifeOpsAnchors(anchorRegistry);
+    registerAnchorRegistry(runtime, anchorRegistry);
+    runtime.anchorRegistry = anchorRegistry;
+    const eventKindRegistry = createEventKindRegistry();
+    registerAppLifeOpsEventKinds(eventKindRegistry);
+    registerEventKindRegistry(runtime, eventKindRegistry);
+    runtime.eventKindRegistry = eventKindRegistry;
+    const familyRegistry = createFamilyRegistry();
+    registerBuiltinTelemetryFamilies(familyRegistry);
+    registerAppLifeOpsBusFamilies(familyRegistry);
+    registerFamilyRegistry(runtime, familyRegistry);
+    runtime.busFamilyRegistry = familyRegistry;
+    const workflowStepRegistry = createWorkflowStepRegistry();
+    registerDefaultWorkflowStepPack(workflowStepRegistry);
+    registerWorkflowStepRegistry(runtime, workflowStepRegistry);
+    runtime.workflowStepRegistry = workflowStepRegistry;
+    registerDefaultFeatureFlagPack(runtime);
+    const activitySignalBus = createActivitySignalBus({ familyRegistry });
+    registerActivitySignalBus(runtime, activitySignalBus);
+    await ensureLifeOpsHealthPluginRegistered(runtime);
+    const ownerFactStore = createOwnerFactStore(runtime);
+    registerOwnerFactStore(runtime, ownerFactStore);
+    const promptRegistry = createMultilingualPromptRegistry();
+    registerDefaultPromptPack(promptRegistry);
+    registerMultilingualPromptRegistry(runtime, promptRegistry);
+    registerLocalizedExamplesProvider(
+      runtime,
+      createOwnerLocaleExamplesProvider(runtime)
+    );
+    registerSendPolicy(runtime, createOwnerSendPolicy());
+    runtime.lifeOpsMessageActionHook = {
+      handleMessageAction: handleLifeOpsMessageAction
+    };
+    runtime.lifeOpsDirectMessageHook = {
+      handleMessageRequest: handleLifeOpsDirectMessageRequest
+    };
+    const triage = getDefaultTriageService();
+    triage.register(new GoogleGmailAdapter());
+    triage.register(new XDmAdapter());
+    triage.register(new CalendlyAdapter());
+    triage.register(new BrowserBridgeAdapter());
+    const proactiveAgentDisabled = isDisabledByEnv(
+      "ELIZA_DISABLE_PROACTIVE_AGENT"
+    );
+    if (!proactiveAgentDisabled) {
+      registerProactiveTaskWorker(runtime);
+      scheduleTaskEnsureAfterRuntimeInit({
+        runtime,
+        prefix: "[proactive]",
+        label: "task",
+        ensure: async () => {
+          if (!isAppFirstRunComplete()) return;
+          await ensureProactiveAgentTask(runtime);
+        }
+      });
+    } else {
+      runtime.logger.info(
+        "[proactive] Proactive agent task skipped \u2014 ELIZA_DISABLE_PROACTIVE_AGENT=1"
+      );
+    }
+    registerFollowupTrackerWorker(runtime);
+    scheduleTaskEnsureAfterRuntimeInit({
+      runtime,
+      prefix: "[followup-tracker]",
+      label: "task",
+      ensure: async () => {
+        await ensureFollowupTrackerTask(runtime);
+      }
+    });
+    registerBlockRuleReconcilerWorker(runtime);
+    scheduleTaskEnsureAfterRuntimeInit({
+      runtime,
+      prefix: "[lifeops]",
+      label: "inbox cache schema",
+      ensure: async () => {
+        await LifeOpsRepository.ensureInboxCacheIndexes(runtime);
+      }
+    });
+    const lifeOpsSchedulerDisabled = isDisabledByEnv(
+      "ELIZA_DISABLE_LIFEOPS_SCHEDULER"
+    );
+    if (!lifeOpsSchedulerDisabled) {
+      registerLifeOpsTaskWorker(runtime);
+      scheduleTaskEnsureAfterRuntimeInit({
+        runtime,
+        prefix: "[lifeops]",
+        label: "scheduler task",
+        ensure: async () => {
+          await ensureLifeOpsSchedulerTask(runtime);
+        }
+      });
+    } else {
+      runtime.logger.info(
+        "[lifeops] Scheduler task skipped \u2014 ELIZA_DISABLE_LIFEOPS_SCHEDULER=1"
+      );
+    }
+  },
+  /**
+   * Tear down everything `init` registered so `runtime.unloadPlugin(...)`
+   * produces an actually-stopped LifeOps:
+   *   - Unregister task workers (proactive, follow-up, scheduler)
+   *   - Delete the persisted task rows that reference those workers
+   *
+   * Routes, services, actions, providers, and event listeners are cleaned
+   * up automatically by the runtime's plugin-lifecycle teardown — no need
+   * to touch those here.
+   */
+  dispose: async (runtime) => {
+    delete runtime.lifeOpsMessageActionHook;
+    delete runtime.lifeOpsDirectMessageHook;
+    const taskNames = [
+      PROACTIVE_TASK_NAME,
+      LIFEOPS_TASK_NAME,
+      FOLLOWUP_TRACKER_TASK_NAME
+    ];
+    for (const name of taskNames) {
+      try {
+        const tasks = await runtime.getTasks({
+          agentIds: [runtime.agentId]
+        });
+        for (const task of tasks) {
+          if (task.name === name && task.id) {
+            try {
+              await runtime.deleteTask(task.id);
+            } catch (err) {
+              const msg = err instanceof Error ? err.message : String(err);
+              runtime.logger.warn(
+                `[lifeops:dispose] Failed to delete task ${name} (${task.id}): ${msg}`
+              );
+            }
+          }
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        runtime.logger.warn(
+          `[lifeops:dispose] Failed to list tasks for "${name}": ${msg}`
+        );
+      }
+    }
+    for (const name of taskNames) {
+      try {
+        runtime.unregisterTaskWorker(name);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        runtime.logger.warn(
+          `[lifeops:dispose] Failed to unregister task worker "${name}": ${msg}`
+        );
+      }
+    }
+  }
+};
+const personalAssistantPlugin = rawPersonalAssistantPlugin;
+import { appBlockerProvider } from "@elizaos/plugin-blocker/providers/app-blocker";
+import {
+  getAppBlockerPermissionState,
+  getAppBlockerStatus,
+  getCachedAppBlockerStatus,
+  getInstalledApps,
+  requestAppBlockerPermission,
+  selectAppsForBlocking,
+  startAppBlock,
+  stopAppBlock
+} from "@elizaos/plugin-blocker/services/app-blocker/index";
+import { workThreadAction as workThreadAction2 } from "./actions/work-thread.js";
+import {
+  computeOverdueFollowups,
+  FOLLOWUP_DEFAULT_THRESHOLD_DAYS,
+  FOLLOWUP_MEMORY_TABLE,
+  FOLLOWUP_TRACKER_INTERVAL_MS,
+  FOLLOWUP_TRACKER_TASK_NAME as FOLLOWUP_TRACKER_TASK_NAME2,
+  FOLLOWUP_TRACKER_TASK_TAGS,
+  getFollowupTrackerRoomId,
+  listOverdueFollowupsAction,
+  markFollowupDoneAction,
+  reconcileFollowupsOnce,
+  registerFollowupTrackerWorker as registerFollowupTrackerWorker2,
+  setFollowupThresholdAction,
+  writeOverdueDigestMemory
+} from "./followup/index.js";
+import { CheckinService } from "./lifeops/checkin/checkin-service.js";
+import { resolveCheckinSchedule } from "./lifeops/checkin/schedule-resolver.js";
+import {
+  FirstRunService,
+  setScheduledTaskRunner
+} from "./lifeops/first-run/service.js";
+import {
+  createFirstRunStateStore,
+  createOwnerFactStore as createOwnerFactStore2
+} from "./lifeops/first-run/state.js";
+import {
+  createGlobalPauseStore,
+  resolveGlobalPauseStore
+} from "./lifeops/global-pause/store.js";
+import {
+  createHandoffStore,
+  describeResumeCondition,
+  evaluateResume,
+  resolveHandoffStore
+} from "./lifeops/handoff/store.js";
+import {
+  createMultilingualPromptRegistry as createMultilingualPromptRegistry2,
+  getDefaultPromptExamplePair,
+  getDefaultPromptRegistry,
+  getMultilingualPromptRegistry,
+  PROMPT_REGISTRY_DEFAULT_LOCALE,
+  registerDefaultPromptPack as registerDefaultPromptPack2,
+  registerMultilingualPromptRegistry as registerMultilingualPromptRegistry2,
+  resolveActionExamplePairs
+} from "./lifeops/i18n/prompt-registry.js";
+import {
+  getOwnerFactStore,
+  ownerFactsToView,
+  registerOwnerFactStore as registerOwnerFactStore2,
+  resolveOwnerFactStore
+} from "./lifeops/owner/fact-store.js";
+import {
+  createPendingPromptsStore,
+  resolvePendingPromptsStore
+} from "./lifeops/pending-prompts/store.js";
+import {
+  ensureLifeOpsSchedulerTask as ensureLifeOpsSchedulerTask2,
+  executeLifeOpsSchedulerTask,
+  LIFEOPS_TASK_INTERVAL_MS,
+  LIFEOPS_TASK_JITTER_MS,
+  LIFEOPS_TASK_NAME as LIFEOPS_TASK_NAME2,
+  LIFEOPS_TASK_TAGS,
+  registerLifeOpsTaskWorker as registerLifeOpsTaskWorker2,
+  resolveLifeOpsTaskIntervalMs
+} from "./lifeops/runtime.js";
+import {
+  createAnchorRegistry as createAnchorRegistry2,
+  createCompletionCheckRegistry,
+  createConsolidationRegistry,
+  createEscalationLadderRegistry,
+  createInMemoryScheduledTaskLogStore,
+  createInMemoryScheduledTaskStore,
+  createScheduledTaskRunner,
+  createTaskGateRegistry,
+  DEFAULT_ESCALATION_LADDERS,
+  PRIORITY_DEFAULT_LADDER_KEYS,
+  processDueScheduledTasks,
+  registerBuiltInCompletionChecks,
+  registerBuiltInGates,
+  registerDefaultEscalationLadders,
+  registerFallbackAnchors,
+  STATE_LOG_DEFAULT_RETENTION_DAYS
+} from "./lifeops/scheduled-task/index.js";
+import { createRuntimeScheduledTaskRunner } from "./lifeops/scheduled-task/runtime-wiring.js";
+import {
+  getScheduledTaskRunner,
+  ScheduledTaskRunnerService as ScheduledTaskRunnerService2
+} from "./lifeops/scheduled-task/service.js";
+import { threadOpsFieldEvaluator as threadOpsFieldEvaluator2 } from "./lifeops/work-threads/field-evaluator-thread-ops.js";
+import {
+  createWorkThreadStore
+} from "./lifeops/work-threads/index.js";
+import { firstRunProvider as firstRunProvider2 } from "./providers/first-run.js";
+import { healthProvider as healthProvider2 } from "./providers/health.js";
+import { inboxTriageProvider as inboxTriageProvider2 } from "./providers/inbox-triage.js";
+import { lifeOpsProvider as lifeOpsProvider2 } from "./providers/lifeops.js";
+import {
+  createPendingPromptsProvider,
+  pendingPromptsProvider as pendingPromptsProvider2
+} from "./providers/pending-prompts.js";
+import {
+  createRecentTaskStatesProvider,
+  recentTaskStatesProvider as recentTaskStatesProvider2
+} from "./providers/recent-task-states.js";
+import { roomPolicyProvider as roomPolicyProvider2 } from "./providers/room-policy.js";
+import { workThreadsProvider as workThreadsProvider2 } from "./providers/work-threads.js";
+import { handleLifeOpsRoutes } from "./routes/lifeops-routes.js";
+import { handleWebsiteBlockerRoutes } from "./routes/website-blocker-routes.js";
+export {
+  BrowserBridgePluginService,
+  CheckinService,
+  DEFAULT_ESCALATION_LADDERS,
+  FOLLOWUP_DEFAULT_THRESHOLD_DAYS,
+  FOLLOWUP_MEMORY_TABLE,
+  FOLLOWUP_TRACKER_INTERVAL_MS,
+  FOLLOWUP_TRACKER_TASK_NAME2 as FOLLOWUP_TRACKER_TASK_NAME,
+  FOLLOWUP_TRACKER_TASK_TAGS,
+  FirstRunService,
+  LIFEOPS_TASK_INTERVAL_MS,
+  LIFEOPS_TASK_JITTER_MS,
+  LIFEOPS_TASK_NAME2 as LIFEOPS_TASK_NAME,
+  LIFEOPS_TASK_TAGS,
+  PRIORITY_DEFAULT_LADDER_KEYS,
+  PROMPT_REGISTRY_DEFAULT_LOCALE,
+  STATE_LOG_DEFAULT_RETENTION_DAYS,
+  ScheduledTaskRunnerService2 as ScheduledTaskRunnerService,
+  appBlockerProvider,
+  browserBridgeProvider,
+  computeOverdueFollowups,
+  createAnchorRegistry2 as createAnchorRegistry,
+  createCompletionCheckRegistry,
+  createConsolidationRegistry,
+  createEscalationLadderRegistry,
+  createFirstRunStateStore,
+  createGlobalPauseStore,
+  createHandoffStore,
+  createInMemoryScheduledTaskLogStore,
+  createInMemoryScheduledTaskStore,
+  createMultilingualPromptRegistry2 as createMultilingualPromptRegistry,
+  createOwnerFactStore2 as createOwnerFactStore,
+  createPendingPromptsProvider,
+  createPendingPromptsStore,
+  createRecentTaskStatesProvider,
+  createRuntimeScheduledTaskRunner,
+  createScheduledTaskRunner,
+  createTaskGateRegistry,
+  createWorkThreadStore,
+  describeResumeCondition,
+  ensureLifeOpsCalendarPluginRegistered,
+  ensureLifeOpsFinancesPluginRegistered,
+  ensureLifeOpsGoalsPluginRegistered,
+  ensureLifeOpsGooglePluginRegistered,
+  ensureLifeOpsHealthPluginRegistered,
+  ensureLifeOpsInboxPluginRegistered,
+  ensureLifeOpsRemindersPluginRegistered,
+  ensureLifeOpsRemoteDesktopPluginRegistered,
+  ensureLifeOpsSchedulerTask2 as ensureLifeOpsSchedulerTask,
+  evaluateResume,
+  executeLifeOpsSchedulerTask,
+  firstRunProvider2 as firstRunProvider,
+  getAppBlockerPermissionState,
+  getAppBlockerStatus,
+  getCachedAppBlockerStatus,
+  getDefaultPromptExamplePair,
+  getDefaultPromptRegistry,
+  getFollowupTrackerRoomId,
+  getInstalledApps,
+  getMultilingualPromptRegistry,
+  getOwnerFactStore,
+  getScheduledTaskRunner,
+  handleLifeOpsRoutes,
+  handleWebsiteBlockerRoutes,
+  healthProvider2 as healthProvider,
+  inboxTriageProvider2 as inboxTriageProvider,
+  lifeOpsProvider2 as lifeOpsProvider,
+  listOverdueFollowupsAction,
+  markFollowupDoneAction,
+  ownerFactsToView,
+  pendingPromptsProvider2 as pendingPromptsProvider,
+  personalAssistantPlugin,
+  processDueScheduledTasks,
+  recentTaskStatesProvider2 as recentTaskStatesProvider,
+  reconcileFollowupsOnce,
+  registerBuiltInCompletionChecks,
+  registerBuiltInGates,
+  registerDefaultEscalationLadders,
+  registerDefaultPromptPack2 as registerDefaultPromptPack,
+  registerFallbackAnchors,
+  registerFollowupTrackerWorker2 as registerFollowupTrackerWorker,
+  registerLifeOpsTaskWorker2 as registerLifeOpsTaskWorker,
+  registerMultilingualPromptRegistry2 as registerMultilingualPromptRegistry,
+  registerOwnerFactStore2 as registerOwnerFactStore,
+  requestAppBlockerPermission,
+  resolveActionExamplePairs,
+  resolveCheckinSchedule,
+  resolveGlobalPauseStore,
+  resolveHandoffStore,
+  resolveLifeOpsTaskIntervalMs,
+  resolveOwnerFactStore,
+  resolvePendingPromptsStore,
+  roomPolicyProvider2 as roomPolicyProvider,
+  selectAppsForBlocking,
+  setFollowupThresholdAction,
+  setScheduledTaskRunner,
+  startAppBlock,
+  stopAppBlock,
+  threadOpsFieldEvaluator2 as threadOpsFieldEvaluator,
+  workThreadAction2 as workThreadAction,
+  workThreadsProvider2 as workThreadsProvider,
+  writeOverdueDigestMemory
+};
+//# sourceMappingURL=plugin.js.map