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

package/dist/lifeops/scheduled-task/scheduler.d.ts

@@ -0,0 +1,28 @@
+import { type IAgentRuntime } from "@elizaos/core";
+import type { ScheduledTask } from "@elizaos/plugin-scheduling";
+import { type RecordedPendingPrompt } from "../pending-prompts/store.js";
+export interface ProcessDueScheduledTasksRequest {
+    runtime: IAgentRuntime;
+    agentId: string;
+    now: Date;
+    limit: number;
+}
+export interface ScheduledTaskFireResult {
+    taskId: string;
+    status: ScheduledTask["state"]["status"];
+    reason: string;
+    occurrenceAtIso?: string;
+}
+export interface ScheduledTaskProcessingError {
+    taskId: string;
+    phase: "fire" | "completion_timeout" | "pending_prompt";
+    message: string;
+}
+export interface ProcessDueScheduledTasksResult {
+    fires: ScheduledTaskFireResult[];
+    completionTimeouts: ScheduledTaskFireResult[];
+    pendingPrompts: RecordedPendingPrompt[];
+    errors: ScheduledTaskProcessingError[];
+}
+export declare function processDueScheduledTasks(request: ProcessDueScheduledTasksRequest): Promise<ProcessDueScheduledTasksResult>;
+//# sourceMappingURL=scheduler.d.ts.map

package/dist/lifeops/scheduled-task/scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../../src/lifeops/scheduled-task/scheduler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAU,MAAM,eAAe,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAchE,OAAO,EACL,KAAK,qBAAqB,EAE3B,MAAM,6BAA6B,CAAC;AAIrC,MAAM,WAAW,+BAA+B;IAC9C,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,IAAI,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,CAAC;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,4BAA4B;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,GAAG,oBAAoB,GAAG,gBAAgB,CAAC;IACxD,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,8BAA8B;IAC7C,KAAK,EAAE,uBAAuB,EAAE,CAAC;IACjC,kBAAkB,EAAE,uBAAuB,EAAE,CAAC;IAC9C,cAAc,EAAE,qBAAqB,EAAE,CAAC;IACxC,MAAM,EAAE,4BAA4B,EAAE,CAAC;CACxC;AAuCD,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,+BAA+B,GACvC,OAAO,CAAC,8BAA8B,CAAC,CAgHzC"}

package/dist/lifeops/scheduled-task/scheduler.js

@@ -0,0 +1,202 @@
+import { logger } from "@elizaos/core";
+import {
+  expectedReplyKindForTask,
+  getAnchorRegistry,
+  isCompletionTimeoutDue,
+  isRecurringTrigger,
+  isScheduledTaskDue,
+  markWindowFireIfNeeded,
+  pendingPromptRoomIdForTask
+} from "@elizaos/plugin-scheduling";
+import {
+  ownerFactsToView,
+  resolveOwnerFactStore
+} from "../owner/fact-store.js";
+import {
+  resolvePendingPromptsStore
+} from "../pending-prompts/store.js";
+import { LifeOpsRepository } from "../repository.js";
+import { getScheduledTaskRunner } from "./service.js";
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function shouldRecordPendingPrompt(task) {
+  return task.completionCheck?.kind === "user_replied_within" || task.completionCheck?.kind === "user_acknowledged" || task.kind === "approval";
+}
+async function recordPendingPromptIfNeeded(args) {
+  if (args.result.state.status !== "fired") return null;
+  if (!shouldRecordPendingPrompt(args.result)) return null;
+  const roomId = pendingPromptRoomIdForTask(args.result);
+  if (!roomId || !args.result.state.firedAt) return null;
+  const store = resolvePendingPromptsStore(args.runtime);
+  return store.record({
+    roomId,
+    taskId: args.result.taskId,
+    promptSnippet: args.result.promptInstructions,
+    firedAt: args.result.state.firedAt,
+    expectedReplyKind: expectedReplyKindForTask(args.result),
+    expiresAt: typeof args.result.completionCheck?.followupAfterMinutes === "number" ? new Date(
+      Date.parse(args.result.state.firedAt) + args.result.completionCheck.followupAfterMinutes * 6e4
+    ).toISOString() : void 0
+  });
+}
+async function processDueScheduledTasks(request) {
+  const result = {
+    fires: [],
+    completionTimeouts: [],
+    pendingPrompts: [],
+    errors: []
+  };
+  const limit = Math.max(1, Math.floor(request.limit));
+  const repo = new LifeOpsRepository(request.runtime);
+  const runner = getScheduledTaskRunner(request.runtime, {
+    agentId: request.agentId,
+    now: () => request.now
+  });
+  const ownerFacts = ownerFactsToView(
+    await resolveOwnerFactStore(request.runtime).read()
+  );
+  const dueContext = {
+    now: request.now,
+    ownerFacts,
+    anchors: getAnchorRegistry(request.runtime)
+  };
+  const nowIso = request.now.toISOString();
+  const dueCandidates = await repo.listScheduledTasks(request.agentId, {
+    status: ["scheduled", "fired"],
+    dueAtOrBeforeIso: nowIso
+  });
+  const timeoutCandidates = await repo.listScheduledTasks(request.agentId, {
+    status: ["fired"]
+  });
+  const timeoutTaskIds = /* @__PURE__ */ new Set();
+  for (const task of timeoutCandidates) {
+    if (result.fires.length + result.completionTimeouts.length >= limit) {
+      break;
+    }
+    const timeout = isCompletionTimeoutDue(task, request.now);
+    if (timeout.due) {
+      try {
+        const skipped = await runner.apply(task.taskId, "skip", {
+          reason: timeout.reason
+        });
+        result.completionTimeouts.push({
+          taskId: skipped.taskId,
+          status: skipped.state.status,
+          reason: timeout.reason,
+          occurrenceAtIso: timeout.occurrenceAtIso
+        });
+        timeoutTaskIds.add(skipped.taskId);
+      } catch (error) {
+        const message = errorMessage(error);
+        logger.warn(
+          `[lifeops-scheduled-task] completion timeout failed for ${task.taskId}: ${message}`
+        );
+        result.errors.push({
+          taskId: task.taskId,
+          phase: "completion_timeout",
+          message
+        });
+      }
+    }
+  }
+  for (const task of dueCandidates) {
+    if (timeoutTaskIds.has(task.taskId)) continue;
+    if (result.fires.length + result.completionTimeouts.length >= limit) {
+      break;
+    }
+    const decision = await isScheduledTaskDue(task, dueContext);
+    if (!decision.due) continue;
+    try {
+      const fireResult = await runner.fireWithResult(task.taskId, {
+        allowTerminalRefire: isRecurringTrigger(task.trigger)
+      });
+      const fired = await handleFireResult({
+        request,
+        repo,
+        fireResult,
+        decision,
+        dueContext,
+        result
+      });
+      if (!fired) continue;
+    } catch (error) {
+      const message = errorMessage(error);
+      logger.warn(
+        `[lifeops-scheduled-task] fire failed for ${task.taskId}: ${message}`
+      );
+      result.errors.push({ taskId: task.taskId, phase: "fire", message });
+    }
+  }
+  return result;
+}
+async function handleFireResult(args) {
+  const { request, fireResult, decision, dueContext, result } = args;
+  switch (fireResult.kind) {
+    case "raced": {
+      return false;
+    }
+    case "skipped": {
+      result.fires.push({
+        taskId: fireResult.task.taskId,
+        status: fireResult.task.state.status,
+        reason: fireResult.reason || decision.reason,
+        occurrenceAtIso: decision.occurrenceAtIso
+      });
+      return true;
+    }
+    case "dispatch_failed": {
+      result.errors.push({
+        taskId: fireResult.task.taskId,
+        phase: "fire",
+        message: fireResult.error.message
+      });
+      return true;
+    }
+    case "fired": {
+      const windowMetadata = markWindowFireIfNeeded(
+        fireResult.task,
+        dueContext
+      );
+      const runner = getScheduledTaskRunner(request.runtime, {
+        agentId: request.agentId,
+        now: () => request.now
+      });
+      const persisted = windowMetadata !== null ? await runner.apply(fireResult.task.taskId, "edit", {
+        metadata: windowMetadata
+      }) : fireResult.task;
+      result.fires.push({
+        taskId: persisted.taskId,
+        status: persisted.state.status,
+        reason: decision.reason,
+        occurrenceAtIso: decision.occurrenceAtIso
+      });
+      try {
+        const recorded = await recordPendingPromptIfNeeded({
+          runtime: request.runtime,
+          result: persisted
+        });
+        if (recorded) result.pendingPrompts.push(recorded);
+      } catch (error) {
+        const message = errorMessage(error);
+        logger.warn(
+          `[lifeops-scheduled-task] pending prompt record failed for ${fireResult.task.taskId}: ${message}`
+        );
+        result.errors.push({
+          taskId: fireResult.task.taskId,
+          phase: "pending_prompt",
+          message
+        });
+      }
+      return true;
+    }
+    default: {
+      const _exhaustive = fireResult;
+      return false;
+    }
+  }
+}
+export {
+  processDueScheduledTasks
+};
+//# sourceMappingURL=scheduler.js.map

package/dist/lifeops/scheduled-task/scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lifeops/scheduled-task/scheduler.ts"],"sourcesContent":["import { type IAgentRuntime, logger } from \"@elizaos/core\";\nimport type { ScheduledTask } from \"@elizaos/plugin-scheduling\";\nimport {\n  expectedReplyKindForTask,\n  getAnchorRegistry,\n  isCompletionTimeoutDue,\n  isRecurringTrigger,\n  isScheduledTaskDue,\n  markWindowFireIfNeeded,\n  pendingPromptRoomIdForTask,\n} from \"@elizaos/plugin-scheduling\";\nimport {\n  ownerFactsToView,\n  resolveOwnerFactStore,\n} from \"../owner/fact-store.js\";\nimport {\n  type RecordedPendingPrompt,\n  resolvePendingPromptsStore,\n} from \"../pending-prompts/store.js\";\nimport { LifeOpsRepository } from \"../repository.js\";\nimport { getScheduledTaskRunner } from \"./service.js\";\n\nexport interface ProcessDueScheduledTasksRequest {\n  runtime: IAgentRuntime;\n  agentId: string;\n  now: Date;\n  limit: number;\n}\n\nexport interface ScheduledTaskFireResult {\n  taskId: string;\n  status: ScheduledTask[\"state\"][\"status\"];\n  reason: string;\n  occurrenceAtIso?: string;\n}\n\nexport interface ScheduledTaskProcessingError {\n  taskId: string;\n  phase: \"fire\" | \"completion_timeout\" | \"pending_prompt\";\n  message: string;\n}\n\nexport interface ProcessDueScheduledTasksResult {\n  fires: ScheduledTaskFireResult[];\n  completionTimeouts: ScheduledTaskFireResult[];\n  pendingPrompts: RecordedPendingPrompt[];\n  errors: ScheduledTaskProcessingError[];\n}\n\nfunction errorMessage(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n\nfunction shouldRecordPendingPrompt(task: ScheduledTask): boolean {\n  return (\n    task.completionCheck?.kind === \"user_replied_within\" ||\n    task.completionCheck?.kind === \"user_acknowledged\" ||\n    task.kind === \"approval\"\n  );\n}\n\nasync function recordPendingPromptIfNeeded(args: {\n  runtime: IAgentRuntime;\n  result: ScheduledTask;\n}): Promise<RecordedPendingPrompt | null> {\n  if (args.result.state.status !== \"fired\") return null;\n  if (!shouldRecordPendingPrompt(args.result)) return null;\n  const roomId = pendingPromptRoomIdForTask(args.result);\n  if (!roomId || !args.result.state.firedAt) return null;\n  const store = resolvePendingPromptsStore(args.runtime);\n  return store.record({\n    roomId,\n    taskId: args.result.taskId,\n    promptSnippet: args.result.promptInstructions,\n    firedAt: args.result.state.firedAt,\n    expectedReplyKind: expectedReplyKindForTask(args.result),\n    expiresAt:\n      typeof args.result.completionCheck?.followupAfterMinutes === \"number\"\n        ? new Date(\n            Date.parse(args.result.state.firedAt) +\n              args.result.completionCheck.followupAfterMinutes * 60_000,\n          ).toISOString()\n        : undefined,\n  });\n}\n\nexport async function processDueScheduledTasks(\n  request: ProcessDueScheduledTasksRequest,\n): Promise<ProcessDueScheduledTasksResult> {\n  const result: ProcessDueScheduledTasksResult = {\n    fires: [],\n    completionTimeouts: [],\n    pendingPrompts: [],\n    errors: [],\n  };\n  const limit = Math.max(1, Math.floor(request.limit));\n  const repo = new LifeOpsRepository(request.runtime);\n  // The runner is constructed ONCE per runtime by ScheduledTaskRunnerService\n  // (registered in plugin.ts). Reaching for it here every tick is O(map-get),\n  // not the O(register-channels + build-registries) reconstruction the old\n  // `createRuntimeScheduledTaskRunner` call did per minute.\n  const runner = getScheduledTaskRunner(request.runtime, {\n    agentId: request.agentId,\n    now: () => request.now,\n  });\n  const ownerFacts = ownerFactsToView(\n    await resolveOwnerFactStore(request.runtime).read(),\n  );\n  const dueContext = {\n    now: request.now,\n    ownerFacts,\n    anchors: getAnchorRegistry(request.runtime),\n  };\n  // Indexed pass 1: due-to-fire candidates.\n  //\n  // The partial index `idx_life_scheduled_tasks_due` covers\n  // `(agent_id, next_fire_at) WHERE state_json->>'status' IN ('scheduled','fired')`,\n  // so this query touches O(# due rows + # event-driven rows with NULL)\n  // instead of every row owned by the agent. `next_fire_at IS NULL` rows are\n  // included so event / manual / after_task triggers (which deliberately\n  // have no wall-clock fire time) still get a chance at fire-time gates if\n  // they're invoked through another path. The authoritative\n  // `isScheduledTaskDue` re-evaluates per task below.\n  const nowIso = request.now.toISOString();\n  const dueCandidates = await repo.listScheduledTasks(request.agentId, {\n    status: [\"scheduled\", \"fired\"],\n    dueAtOrBeforeIso: nowIso,\n  });\n  // Indexed pass 2: completion-timeout candidates. These are rows that have\n  // already fired (`status = 'fired'`) and have a `followupAfterMinutes` on\n  // the completion-check. The partial index has them too because `fired` is\n  // in the index predicate. `dueAtOrBeforeIso` is intentionally omitted —\n  // a fired row's `next_fire_at` is NULL after the claim, so we filter by\n  // `state.firedAt` in JS via `isCompletionTimeoutDue`.\n  const timeoutCandidates = await repo.listScheduledTasks(request.agentId, {\n    status: [\"fired\"],\n  });\n  const timeoutTaskIds = new Set<string>();\n\n  for (const task of timeoutCandidates) {\n    if (result.fires.length + result.completionTimeouts.length >= limit) {\n      break;\n    }\n    const timeout = isCompletionTimeoutDue(task, request.now);\n    if (timeout.due) {\n      try {\n        const skipped = await runner.apply(task.taskId, \"skip\", {\n          reason: timeout.reason,\n        });\n        result.completionTimeouts.push({\n          taskId: skipped.taskId,\n          status: skipped.state.status,\n          reason: timeout.reason,\n          occurrenceAtIso: timeout.occurrenceAtIso,\n        });\n        timeoutTaskIds.add(skipped.taskId);\n      } catch (error) {\n        const message = errorMessage(error);\n        logger.warn(\n          `[lifeops-scheduled-task] completion timeout failed for ${task.taskId}: ${message}`,\n        );\n        result.errors.push({\n          taskId: task.taskId,\n          phase: \"completion_timeout\",\n          message,\n        });\n      }\n    }\n  }\n\n  for (const task of dueCandidates) {\n    if (timeoutTaskIds.has(task.taskId)) continue;\n    if (result.fires.length + result.completionTimeouts.length >= limit) {\n      break;\n    }\n    const decision = await isScheduledTaskDue(task, dueContext);\n    if (!decision.due) continue;\n    try {\n      const fireResult = await runner.fireWithResult(task.taskId, {\n        allowTerminalRefire: isRecurringTrigger(task.trigger),\n      });\n      const fired = await handleFireResult({\n        request,\n        repo,\n        fireResult,\n        decision,\n        dueContext,\n        result,\n      });\n      if (!fired) continue;\n    } catch (error) {\n      const message = errorMessage(error);\n      logger.warn(\n        `[lifeops-scheduled-task] fire failed for ${task.taskId}: ${message}`,\n      );\n      result.errors.push({ taskId: task.taskId, phase: \"fire\", message });\n    }\n  }\n\n  return result;\n}\n\n/**\n * Branch on the `ScheduledTaskFireResult` discriminated union and record the\n * outcome into the tick result. Returns `true` when the result counted as a\n * fire (so the caller knows it consumed a slot), `false` otherwise.\n */\nasync function handleFireResult(args: {\n  request: ProcessDueScheduledTasksRequest;\n  repo: LifeOpsRepository;\n  fireResult: import(\"@elizaos/plugin-scheduling\").ScheduledTaskFireResult;\n  decision: import(\"@elizaos/plugin-scheduling\").ScheduledTaskDueDecision;\n  dueContext: import(\"@elizaos/plugin-scheduling\").ScheduledTaskDueContext;\n  result: ProcessDueScheduledTasksResult;\n}): Promise<boolean> {\n  const { request, fireResult, decision, dueContext, result } = args;\n  switch (fireResult.kind) {\n    case \"raced\": {\n      // Another tick atomically claimed this row first. Nothing to record —\n      // the winning tick will publish its own fire event. Surfacing this as\n      // an error would double-count; surfacing as a fire would double-bill.\n      return false;\n    }\n    case \"skipped\": {\n      // Gate denial / global-pause / terminal-non-recurring etc. Recorded so\n      // observers see the task was visited and chose not to dispatch.\n      result.fires.push({\n        taskId: fireResult.task.taskId,\n        status: fireResult.task.state.status,\n        reason: fireResult.reason || decision.reason,\n        occurrenceAtIso: decision.occurrenceAtIso,\n      });\n      return true;\n    }\n    case \"dispatch_failed\": {\n      result.errors.push({\n        taskId: fireResult.task.taskId,\n        phase: \"fire\",\n        message: fireResult.error.message,\n      });\n      return true;\n    }\n    case \"fired\": {\n      const windowMetadata = markWindowFireIfNeeded(\n        fireResult.task,\n        dueContext,\n      );\n      // Service singleton — same instance the scheduler grabbed at the top.\n      const runner = getScheduledTaskRunner(request.runtime, {\n        agentId: request.agentId,\n        now: () => request.now,\n      });\n      const persisted =\n        windowMetadata !== null\n          ? await runner.apply(fireResult.task.taskId, \"edit\", {\n              metadata: windowMetadata,\n            })\n          : fireResult.task;\n      result.fires.push({\n        taskId: persisted.taskId,\n        status: persisted.state.status,\n        reason: decision.reason,\n        occurrenceAtIso: decision.occurrenceAtIso,\n      });\n      try {\n        const recorded = await recordPendingPromptIfNeeded({\n          runtime: request.runtime,\n          result: persisted,\n        });\n        if (recorded) result.pendingPrompts.push(recorded);\n      } catch (error) {\n        const message = errorMessage(error);\n        logger.warn(\n          `[lifeops-scheduled-task] pending prompt record failed for ${fireResult.task.taskId}: ${message}`,\n        );\n        result.errors.push({\n          taskId: fireResult.task.taskId,\n          phase: \"pending_prompt\",\n          message,\n        });\n      }\n      return true;\n    }\n    default: {\n      const _exhaustive: never = fireResult;\n      return false;\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/lifeops/scheduled-task/service.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Long-lived ScheduledTask runner singleton.
+ *
+ * Before this service existed, `processDueScheduledTasks` called
+ * `createRuntimeScheduledTaskRunner` on every tick (every 60s). That call
+ * rebuilds all five typed registries (gates, completion-checks, ladders,
+ * anchors, consolidation), refreshes the channel-keys snapshot, and wires
+ * a fresh `createProductionScheduledTaskDispatcher`. None of that work
+ * varies tick-to-tick — the registries are populated at plugin init and
+ * stay stable. Rebuilding them on a 1-minute cadence was wasteful and
+ * inflated per-tick latency.
+ *
+ * The service builds the runner ONCE per runtime when
+ * `ScheduledTaskRunnerService.start` is invoked by the elizaOS Service
+ * lifecycle, caches it on the instance, and hands it out via
+ * `getScheduledTaskRunner`. The `now` clock and `agentId` are still
+ * accepted per call so the tick can pass its own `request.now` and the
+ * scheduler stays deterministic in tests.
+ *
+ * Registration: see `plugin.ts` → `services: [...,
+ * ScheduledTaskRunnerService]`.
+ */
+import { type IAgentRuntime, Service } from "@elizaos/core";
+import type { ScheduledTaskRunnerHandle } from "@elizaos/plugin-scheduling";
+/**
+ * Options accepted by `getScheduledTaskRunner`. The agentId always comes
+ * from the caller (the tick passes the agent's own id; routes / actions
+ * read it off `runtime.agentId`). The `now` override stays per-call so
+ * tests and time-travel scenarios get the clock they expect. Everything
+ * else lives on the cached runner.
+ */
+export interface GetScheduledTaskRunnerOptions {
+    agentId: string;
+    now?: () => Date;
+}
+export declare class ScheduledTaskRunnerService extends Service {
+    static serviceType: "lifeops_scheduled_task_runner";
+    capabilityDescription: string;
+    private readonly runners;
+    stop(): Promise<void>;
+    static start(runtime: IAgentRuntime): Promise<ScheduledTaskRunnerService>;
+    /**
+     * Return the cached runner for `(agentId, optional now-override)`. The
+     * first call constructs the runner via
+     * {@link createRuntimeScheduledTaskRunner} (one-time registry/dispatcher
+     * wiring); subsequent calls hit the in-memory cache.
+     */
+    getRunner(opts: GetScheduledTaskRunnerOptions): ScheduledTaskRunnerHandle;
+}
+/**
+ * Module-level accessor. Resolves the service via the runtime's service
+ * registry and returns its cached runner. Throws when the service is not
+ * registered — that is a plugin-wiring bug, not a runtime fallback case.
+ *
+ * Used by:
+ *  - `scheduled-task/scheduler.ts` (per-tick `fireWithResult` path)
+ *  - the action and route call sites listed in `runtime-wiring.ts` that
+ *    previously called `createRuntimeScheduledTaskRunner` directly.
+ */
+export declare function getScheduledTaskRunner(runtime: IAgentRuntime, opts: GetScheduledTaskRunnerOptions): ScheduledTaskRunnerHandle;
+//# sourceMappingURL=service.d.ts.map

package/dist/lifeops/scheduled-task/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../src/lifeops/scheduled-task/service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,KAAK,aAAa,EAAU,OAAO,EAAE,MAAM,eAAe,CAAC;AAEpE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAQ5E;;;;;;GAMG;AACH,MAAM,WAAW,6BAA6B;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;CAClB;AAED,qBAAa,0BAA2B,SAAQ,OAAO;IACrD,OAAgB,WAAW,kCAAgB;IAElC,qBAAqB,SAC4L;IAO1N,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgD;IAEzD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;WAId,KAAK,CACzB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,0BAA0B,CAAC;IAQtC;;;;;OAKG;IACH,SAAS,CAAC,IAAI,EAAE,6BAA6B,GAAG,yBAAyB;CAmB1E;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,aAAa,EACtB,IAAI,EAAE,6BAA6B,GAClC,yBAAyB,CAW3B"}

package/dist/lifeops/scheduled-task/service.js

@@ -0,0 +1,64 @@
+import { logger, Service } from "@elizaos/core";
+import {
+  createRuntimeScheduledTaskRunner
+} from "./runtime-wiring.js";
+const SERVICE_TYPE = "lifeops_scheduled_task_runner";
+class ScheduledTaskRunnerService extends Service {
+  static serviceType = SERVICE_TYPE;
+  capabilityDescription = "Long-lived ScheduledTask runner. Hosts gate/completion-check/ladder/anchor/consolidation registries built once at plugin start; the scheduler tick reads the cached runner instead of reconstructing it every minute.";
+  // The runner is keyed by `(agentId, nowOverridePresent)` so callers that
+  // pass distinct `now` overrides get their own handle. In practice the
+  // production tick always passes the same `now` function reference, and
+  // routes / actions never override it — so the cache typically holds one
+  // entry per runtime.
+  runners = /* @__PURE__ */ new Map();
+  async stop() {
+    this.runners.clear();
+  }
+  static async start(runtime) {
+    logger.debug(
+      { src: SERVICE_TYPE, agentId: runtime.agentId },
+      "ScheduledTaskRunnerService started"
+    );
+    return new ScheduledTaskRunnerService(runtime);
+  }
+  /**
+   * Return the cached runner for `(agentId, optional now-override)`. The
+   * first call constructs the runner via
+   * {@link createRuntimeScheduledTaskRunner} (one-time registry/dispatcher
+   * wiring); subsequent calls hit the in-memory cache.
+   */
+  getRunner(opts) {
+    const cacheKey = `${opts.agentId}::${opts.now ? "now-override" : "system-clock"}`;
+    const cached = this.runners.get(cacheKey);
+    if (cached) return cached;
+    const runtime = this.runtime;
+    if (!runtime) {
+      throw new Error(
+        "ScheduledTaskRunnerService: runtime is not bound; was the service started?"
+      );
+    }
+    const runnerOpts = {
+      runtime,
+      agentId: opts.agentId
+    };
+    if (opts.now) runnerOpts.now = opts.now;
+    const runner = createRuntimeScheduledTaskRunner(runnerOpts);
+    this.runners.set(cacheKey, runner);
+    return runner;
+  }
+}
+function getScheduledTaskRunner(runtime, opts) {
+  const service = runtime.getService(SERVICE_TYPE);
+  if (!service) {
+    throw new Error(
+      `[${SERVICE_TYPE}] ScheduledTaskRunnerService is not registered on this runtime. Add it to the lifeops plugin's services array.`
+    );
+  }
+  return service.getRunner(opts);
+}
+export {
+  ScheduledTaskRunnerService,
+  getScheduledTaskRunner
+};
+//# sourceMappingURL=service.js.map

package/dist/lifeops/scheduled-task/service.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lifeops/scheduled-task/service.ts"],"sourcesContent":["/**\n * Long-lived ScheduledTask runner singleton.\n *\n * Before this service existed, `processDueScheduledTasks` called\n * `createRuntimeScheduledTaskRunner` on every tick (every 60s). That call\n * rebuilds all five typed registries (gates, completion-checks, ladders,\n * anchors, consolidation), refreshes the channel-keys snapshot, and wires\n * a fresh `createProductionScheduledTaskDispatcher`. None of that work\n * varies tick-to-tick — the registries are populated at plugin init and\n * stay stable. Rebuilding them on a 1-minute cadence was wasteful and\n * inflated per-tick latency.\n *\n * The service builds the runner ONCE per runtime when\n * `ScheduledTaskRunnerService.start` is invoked by the elizaOS Service\n * lifecycle, caches it on the instance, and hands it out via\n * `getScheduledTaskRunner`. The `now` clock and `agentId` are still\n * accepted per call so the tick can pass its own `request.now` and the\n * scheduler stays deterministic in tests.\n *\n * Registration: see `plugin.ts` → `services: [...,\n * ScheduledTaskRunnerService]`.\n */\n\nimport { type IAgentRuntime, logger, Service } from \"@elizaos/core\";\n\nimport type { ScheduledTaskRunnerHandle } from \"@elizaos/plugin-scheduling\";\nimport {\n  type CreateRuntimeRunnerOptions,\n  createRuntimeScheduledTaskRunner,\n} from \"./runtime-wiring.js\";\n\nconst SERVICE_TYPE = \"lifeops_scheduled_task_runner\" as const;\n\n/**\n * Options accepted by `getScheduledTaskRunner`. The agentId always comes\n * from the caller (the tick passes the agent's own id; routes / actions\n * read it off `runtime.agentId`). The `now` override stays per-call so\n * tests and time-travel scenarios get the clock they expect. Everything\n * else lives on the cached runner.\n */\nexport interface GetScheduledTaskRunnerOptions {\n  agentId: string;\n  now?: () => Date;\n}\n\nexport class ScheduledTaskRunnerService extends Service {\n  static override serviceType = SERVICE_TYPE;\n\n  override capabilityDescription =\n    \"Long-lived ScheduledTask runner. Hosts gate/completion-check/ladder/anchor/consolidation registries built once at plugin start; the scheduler tick reads the cached runner instead of reconstructing it every minute.\";\n\n  // The runner is keyed by `(agentId, nowOverridePresent)` so callers that\n  // pass distinct `now` overrides get their own handle. In practice the\n  // production tick always passes the same `now` function reference, and\n  // routes / actions never override it — so the cache typically holds one\n  // entry per runtime.\n  private readonly runners = new Map<string, ScheduledTaskRunnerHandle>();\n\n  override async stop(): Promise<void> {\n    this.runners.clear();\n  }\n\n  static override async start(\n    runtime: IAgentRuntime,\n  ): Promise<ScheduledTaskRunnerService> {\n    logger.debug(\n      { src: SERVICE_TYPE, agentId: runtime.agentId },\n      \"ScheduledTaskRunnerService started\",\n    );\n    return new ScheduledTaskRunnerService(runtime);\n  }\n\n  /**\n   * Return the cached runner for `(agentId, optional now-override)`. The\n   * first call constructs the runner via\n   * {@link createRuntimeScheduledTaskRunner} (one-time registry/dispatcher\n   * wiring); subsequent calls hit the in-memory cache.\n   */\n  getRunner(opts: GetScheduledTaskRunnerOptions): ScheduledTaskRunnerHandle {\n    const cacheKey = `${opts.agentId}::${opts.now ? \"now-override\" : \"system-clock\"}`;\n    const cached = this.runners.get(cacheKey);\n    if (cached) return cached;\n    const runtime = this.runtime;\n    if (!runtime) {\n      throw new Error(\n        \"ScheduledTaskRunnerService: runtime is not bound; was the service started?\",\n      );\n    }\n    const runnerOpts: CreateRuntimeRunnerOptions = {\n      runtime,\n      agentId: opts.agentId,\n    };\n    if (opts.now) runnerOpts.now = opts.now;\n    const runner = createRuntimeScheduledTaskRunner(runnerOpts);\n    this.runners.set(cacheKey, runner);\n    return runner;\n  }\n}\n\n/**\n * Module-level accessor. Resolves the service via the runtime's service\n * registry and returns its cached runner. Throws when the service is not\n * registered — that is a plugin-wiring bug, not a runtime fallback case.\n *\n * Used by:\n *  - `scheduled-task/scheduler.ts` (per-tick `fireWithResult` path)\n *  - the action and route call sites listed in `runtime-wiring.ts` that\n *    previously called `createRuntimeScheduledTaskRunner` directly.\n */\nexport function getScheduledTaskRunner(\n  runtime: IAgentRuntime,\n  opts: GetScheduledTaskRunnerOptions,\n): ScheduledTaskRunnerHandle {\n  const service = runtime.getService(SERVICE_TYPE) as\n    | ScheduledTaskRunnerService\n    | null\n    | undefined;\n  if (!service) {\n    throw new Error(\n      `[${SERVICE_TYPE}] ScheduledTaskRunnerService is not registered on this runtime. Add it to the lifeops plugin's services array.`,\n    );\n  }\n  return service.getRunner(opts);\n}\n"],"mappings":"AAuBA,SAA6B,QAAQ,eAAe;AAGpD;AAAA,EAEE;AAAA,OACK;AAEP,MAAM,eAAe;AAcd,MAAM,mCAAmC,QAAQ;AAAA,EACtD,OAAgB,cAAc;AAAA,EAErB,wBACP;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOe,UAAU,oBAAI,IAAuC;AAAA,EAEtE,MAAe,OAAsB;AACnC,SAAK,QAAQ,MAAM;AAAA,EACrB;AAAA,EAEA,aAAsB,MACpB,SACqC;AACrC,WAAO;AAAA,MACL,EAAE,KAAK,cAAc,SAAS,QAAQ,QAAQ;AAAA,MAC9C;AAAA,IACF;AACA,WAAO,IAAI,2BAA2B,OAAO;AAAA,EAC/C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,UAAU,MAAgE;AACxE,UAAM,WAAW,GAAG,KAAK,OAAO,KAAK,KAAK,MAAM,iBAAiB,cAAc;AAC/E,UAAM,SAAS,KAAK,QAAQ,IAAI,QAAQ;AACxC,QAAI,OAAQ,QAAO;AACnB,UAAM,UAAU,KAAK;AACrB,QAAI,CAAC,SAAS;AACZ,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AACA,UAAM,aAAyC;AAAA,MAC7C;AAAA,MACA,SAAS,KAAK;AAAA,IAChB;AACA,QAAI,KAAK,IAAK,YAAW,MAAM,KAAK;AACpC,UAAM,SAAS,iCAAiC,UAAU;AAC1D,SAAK,QAAQ,IAAI,UAAU,MAAM;AACjC,WAAO;AAAA,EACT;AACF;AAYO,SAAS,uBACd,SACA,MAC2B;AAC3B,QAAM,UAAU,QAAQ,WAAW,YAAY;AAI/C,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI;AAAA,MACR,IAAI,YAAY;AAAA,IAClB;AAAA,EACF;AACA,SAAO,QAAQ,UAAU,IAAI;AAC/B;","names":[]}

package/dist/lifeops/scheduler-task.d.ts

@@ -0,0 +1,19 @@
+import type { IAgentRuntime, UUID } from "@elizaos/core";
+export declare const LIFEOPS_TASK_NAME: "LIFEOPS_SCHEDULER";
+export declare const LIFEOPS_TASK_TAGS: readonly ["queue", "repeat", "lifeops"];
+/** Base interval for the LifeOps scheduler polling loop. */
+export declare const LIFEOPS_TASK_INTERVAL_MS = 60000;
+/** Maximum deterministic jitter added per agent to avoid synchronized polls. */
+export declare const LIFEOPS_TASK_JITTER_MS = 10000;
+/**
+ * Detect a Postgres "relation does not exist" (42P01) error referencing a
+ * LifeOps-owned table (the `app_lifeops` schema). A persisted scheduler task
+ * can fire from the task queue on restart before this plugin's schema
+ * migration finishes, so the first tick may hit a not-yet-created table.
+ */
+export declare function isMissingLifeOpsRelationError(error: unknown): boolean;
+export declare function rerunLifeOpsPluginMigrations(runtime: IAgentRuntime): Promise<void>;
+export declare function resolveLifeOpsTaskIntervalMs(agentId: UUID): number;
+export declare function ensureRuntimeAgentRecord(runtime: IAgentRuntime): Promise<void>;
+export declare function ensureLifeOpsSchedulerTask(runtime: IAgentRuntime): Promise<UUID>;
+//# sourceMappingURL=scheduler-task.d.ts.map

package/dist/lifeops/scheduler-task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler-task.d.ts","sourceRoot":"","sources":["../../src/lifeops/scheduler-task.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAsB,IAAI,EAAE,MAAM,eAAe,CAAC;AAI7E,eAAO,MAAM,iBAAiB,EAAG,mBAA4B,CAAC;AAC9D,eAAO,MAAM,iBAAiB,yCAA0C,CAAC;AACzE,4DAA4D;AAC5D,eAAO,MAAM,wBAAwB,QAAS,CAAC;AAC/C,gFAAgF;AAChF,eAAO,MAAM,sBAAsB,QAAS,CAAC;AAyE7C;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAyCrE;AAED,wBAAsB,4BAA4B,CAChD,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,IAAI,CAAC,CAEf;AA6BD,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,IAAI,GAAG,MAAM,CAMlE;AAuDD,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,IAAI,CAAC,CAiBf;AAED,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,IAAI,CAAC,CAmCf"}

package/dist/lifeops/scheduler-task.js

@@ -0,0 +1,201 @@
+import { logger, runPluginMigrations, stringToUuid } from "@elizaos/core";
+import { readTwilioCredentialsFromEnv } from "@elizaos/plugin-phone/twilio";
+const LIFEOPS_TASK_NAME = "LIFEOPS_SCHEDULER";
+const LIFEOPS_TASK_TAGS = ["queue", "repeat", "lifeops"];
+const LIFEOPS_TASK_INTERVAL_MS = 6e4;
+const LIFEOPS_TASK_JITTER_MS = 1e4;
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isErrorWithCause(value) {
+  return Boolean(value) && typeof value === "object";
+}
+function isMissingTasksTableError(error) {
+  const queue = [error];
+  const seen = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === void 0 || seen.has(current)) {
+      continue;
+    }
+    seen.add(current);
+    if (current instanceof Error) {
+      if (current.message.includes('relation "tasks" does not exist')) {
+        return true;
+      }
+      if (current.cause !== void 0) {
+        queue.push(current.cause);
+      }
+      continue;
+    }
+    if (!isErrorWithCause(current)) {
+      continue;
+    }
+    if (typeof current.message === "string" && current.message.includes('relation "tasks" does not exist')) {
+      return true;
+    }
+    if (current.code === "42P01" && typeof current.query === "string" && current.query.includes('"tasks"')) {
+      return true;
+    }
+    if (current.cause !== void 0) {
+      queue.push(current.cause);
+    }
+  }
+  return false;
+}
+function isMissingLifeOpsRelationError(error) {
+  const queue = [error];
+  const seen = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === void 0 || seen.has(current)) {
+      continue;
+    }
+    seen.add(current);
+    const message = current instanceof Error ? current.message : isErrorWithCause(current) && typeof current.message === "string" ? current.message : "";
+    if (message.includes("app_lifeops.") && message.includes("does not exist")) {
+      return true;
+    }
+    if (isErrorWithCause(current)) {
+      if (current.code === "42P01" && typeof current.query === "string" && current.query.includes("app_lifeops.")) {
+        return true;
+      }
+      if (current.cause !== void 0) {
+        queue.push(current.cause);
+      }
+    } else if (current instanceof Error && current.cause !== void 0) {
+      queue.push(current.cause);
+    }
+  }
+  return false;
+}
+async function rerunLifeOpsPluginMigrations(runtime) {
+  await rerunPluginMigrations(runtime);
+}
+function isLifeOpsSchedulerTask(task) {
+  const metadata = isRecord(task.metadata) ? task.metadata : null;
+  const scheduler = metadata?.lifeopsScheduler;
+  return task.name === LIFEOPS_TASK_NAME && isRecord(scheduler) && scheduler.kind === "runtime_runner";
+}
+function buildSchedulerMetadata(agentId, current = null) {
+  const intervalMs = resolveLifeOpsTaskIntervalMs(agentId);
+  return {
+    ...current ?? {},
+    updateInterval: intervalMs,
+    baseInterval: intervalMs,
+    blocking: true,
+    lifeopsScheduler: {
+      kind: "runtime_runner",
+      version: 1
+    }
+  };
+}
+function resolveLifeOpsTaskIntervalMs(agentId) {
+  let hash = 0;
+  for (let index = 0; index < agentId.length; index++) {
+    hash = hash * 31 + agentId.charCodeAt(index) >>> 0;
+  }
+  return LIFEOPS_TASK_INTERVAL_MS + hash % (LIFEOPS_TASK_JITTER_MS + 1);
+}
+async function rerunPluginMigrations(runtime) {
+  const runtimeWithPluginMigrations = runtime;
+  if (typeof runtimeWithPluginMigrations.runPluginMigrations === "function") {
+    await runtimeWithPluginMigrations.runPluginMigrations();
+    return;
+  }
+  await runPluginMigrations(runtime);
+}
+async function waitForDbReady(runtime, maxAttempts = 12, delayMs = 500) {
+  let lastError = null;
+  let migrationRepairAttempts = 0;
+  for (let i = 0; i < maxAttempts; i++) {
+    try {
+      await runtime.getTasks({
+        agentIds: [runtime.agentId],
+        tags: ["__db_ready_probe__"]
+      });
+      return;
+    } catch (error) {
+      lastError = error;
+      if (isMissingTasksTableError(error) && migrationRepairAttempts < 2) {
+        migrationRepairAttempts += 1;
+        await rerunPluginMigrations(runtime);
+        continue;
+      }
+      if (i < maxAttempts - 1) {
+        await new Promise((r) => setTimeout(r, delayMs));
+      }
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error("[lifeops] database adapter did not become ready");
+}
+let credentialStatusLogged = false;
+function logCredentialStatus() {
+  if (credentialStatusLogged) return;
+  credentialStatusLogged = true;
+  const hasTwilio = Boolean(readTwilioCredentialsFromEnv());
+  if (!hasTwilio) {
+    logger.info(
+      "[lifeops] Twilio credentials not configured \u2014 SMS and voice reminders will be blocked. Set TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, and TWILIO_PHONE_NUMBER to enable."
+    );
+  }
+}
+async function ensureRuntimeAgentRecord(runtime) {
+  const existing = await runtime.getAgent(runtime.agentId);
+  if (existing) {
+    return;
+  }
+  await runtime.createAgent({
+    ...runtime.character,
+    id: runtime.agentId
+  });
+  const hydrated = await runtime.getAgent(runtime.agentId);
+  if (!hydrated) {
+    throw new Error(
+      `[lifeops] runtime agent ${runtime.agentId} is missing from the agents table`
+    );
+  }
+}
+async function ensureLifeOpsSchedulerTask(runtime) {
+  await waitForDbReady(runtime);
+  await ensureRuntimeAgentRecord(runtime);
+  logCredentialStatus();
+  const tasks = await runtime.getTasks({
+    agentIds: [runtime.agentId],
+    tags: [...LIFEOPS_TASK_TAGS]
+  });
+  const existing = tasks.find(isLifeOpsSchedulerTask);
+  const metadata = buildSchedulerMetadata(
+    runtime.agentId,
+    isRecord(existing?.metadata) ? existing.metadata : null
+  );
+  if (existing?.id) {
+    await runtime.updateTask(existing.id, {
+      description: "Process life-ops reminders and scheduled workflows",
+      metadata
+    });
+    return existing.id;
+  }
+  const autonomy = runtime.getService("AUTONOMY");
+  const roomId = autonomy?.getAutonomousRoomId?.() ?? stringToUuid(`lifeops-scheduler-room-${runtime.agentId}`);
+  return runtime.createTask({
+    name: LIFEOPS_TASK_NAME,
+    description: "Process life-ops reminders and scheduled workflows",
+    roomId,
+    tags: [...LIFEOPS_TASK_TAGS],
+    metadata,
+    dueAt: Date.now()
+  });
+}
+export {
+  LIFEOPS_TASK_INTERVAL_MS,
+  LIFEOPS_TASK_JITTER_MS,
+  LIFEOPS_TASK_NAME,
+  LIFEOPS_TASK_TAGS,
+  ensureLifeOpsSchedulerTask,
+  ensureRuntimeAgentRecord,
+  isMissingLifeOpsRelationError,
+  rerunLifeOpsPluginMigrations,
+  resolveLifeOpsTaskIntervalMs
+};
+//# sourceMappingURL=scheduler-task.js.map