@elizaos/plugin-scheduling 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/scheduled-task/runner.js

@@ -0,0 +1,721 @@
+import {
+  resetLadderForSnooze,
+  resolveEffectiveLadder
+} from "./escalation.js";
+import { computeNextFireAt } from "./next-fire-at.js";
+import { createStateLogger } from "./state-log.js";
+import {
+  APPROVAL_DEFAULT_FOLLOWUP_AFTER_MINUTES,
+  DEFAULT_TASK_EXECUTION_PROFILE,
+  TASK_EXECUTION_PROFILES
+} from "./types.js";
+class ChannelKeyError extends Error {
+  constructor(channelKey, available) {
+    super(
+      `escalation.steps[].channelKey "${channelKey}" is not registered (registered: ${available.join(", ") || "<none>"})`
+    );
+    this.channelKey = channelKey;
+    this.available = available;
+    this.name = "ChannelKeyError";
+  }
+  channelKey;
+  available;
+  code = "channel_key_unknown";
+}
+function createInMemoryScheduledTaskStore() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    async upsert(task) {
+      map.set(task.taskId, structuredClone(task));
+    },
+    async claimForFire({ taskId, firedAtIso }) {
+      const existing = map.get(taskId);
+      if (existing?.state.status !== "scheduled") {
+        return { kind: "raced" };
+      }
+      const next = structuredClone(existing);
+      next.state.status = "fired";
+      next.state.firedAt = firedAtIso;
+      map.set(taskId, next);
+      return { kind: "fired", task: structuredClone(next) };
+    },
+    async get(taskId) {
+      const found = map.get(taskId);
+      return found ? structuredClone(found) : null;
+    },
+    async findByIdempotencyKey(key) {
+      for (const t of map.values()) {
+        if (t.idempotencyKey === key) {
+          return structuredClone(t);
+        }
+      }
+      return null;
+    },
+    async list(filter) {
+      let view = Array.from(map.values()).map((t) => structuredClone(t));
+      if (!filter) return view;
+      if (filter.kind) view = view.filter((t) => t.kind === filter.kind);
+      if (filter.status) {
+        const allowed = Array.isArray(filter.status) ? new Set(filter.status) : /* @__PURE__ */ new Set([filter.status]);
+        view = view.filter((t) => allowed.has(t.state.status));
+      }
+      if (filter.subject) {
+        view = view.filter(
+          (t) => t.subject?.kind === filter.subject?.kind && t.subject?.id === filter.subject?.id
+        );
+      }
+      if (filter.source) view = view.filter((t) => t.source === filter.source);
+      if (filter.firedSince) {
+        view = view.filter(
+          (t) => typeof t.state.firedAt === "string" && t.state.firedAt >= (filter.firedSince ?? "")
+        );
+      }
+      if (filter.ownerVisibleOnly) view = view.filter((t) => t.ownerVisible);
+      return view;
+    },
+    async delete(taskId) {
+      map.delete(taskId);
+    }
+  };
+}
+const TestNoopScheduledTaskDispatcher = {
+  async dispatch() {
+  }
+};
+const ALL_PROFILES_AVAILABLE = new Set(
+  TASK_EXECUTION_PROFILES
+);
+function defaultTaskIdGenerator() {
+  return `st_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function isTerminal(status) {
+  return status === "completed" || status === "skipped" || status === "expired" || status === "failed" || status === "dismissed";
+}
+function isRecurringTrigger(trigger) {
+  return trigger.kind === "cron" || trigger.kind === "interval" || trigger.kind === "relative_to_anchor" || trigger.kind === "during_window";
+}
+function setEscalationCursor(task, cursor) {
+  task.metadata = {
+    ...task.metadata ?? {},
+    escalationCursor: { ...cursor }
+  };
+}
+function clearEscalationCursor(task) {
+  if (task.metadata && "escalationCursor" in task.metadata) {
+    const next = { ...task.metadata };
+    delete next.escalationCursor;
+    task.metadata = next;
+  }
+}
+function stripServerManaged(task) {
+  const { taskId: _id, state: _state, ...rest } = task;
+  return rest;
+}
+function createScheduledTaskRunner(deps) {
+  const newTaskId = deps.newTaskId ?? defaultTaskIdGenerator;
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  const dispatcher = deps.dispatcher;
+  const logger = createStateLogger({
+    store: deps.logStore,
+    agentId: deps.agentId,
+    now
+  });
+  async function evaluateGates(task) {
+    const compose = task.shouldFire?.compose ?? "first_deny";
+    const gates = task.shouldFire?.gates ?? [];
+    if (gates.length === 0) {
+      return { decision: { kind: "allow" } };
+    }
+    const ownerFacts = await deps.ownerFacts();
+    const ctx = {
+      task,
+      nowIso: now().toISOString(),
+      ownerFacts,
+      activity: deps.activity,
+      subjectStore: deps.subjectStore
+    };
+    const decisions = [];
+    for (const gateRef of gates) {
+      const contrib = deps.gates.get(gateRef.kind);
+      if (!contrib) {
+        return {
+          gateKind: gateRef.kind,
+          decision: {
+            kind: "deny",
+            reason: `unknown gate kind: ${gateRef.kind}`
+          }
+        };
+      }
+      const decision = await contrib.evaluate(task, ctx);
+      decisions.push({ gateKind: gateRef.kind, decision });
+      if (compose === "first_deny" && decision.kind !== "allow") {
+        return { gateKind: gateRef.kind, decision };
+      }
+      if (compose === "any" && decision.kind === "allow") {
+        return { gateKind: gateRef.kind, decision: { kind: "allow" } };
+      }
+    }
+    if (compose === "all") {
+      const denied = decisions.find((d) => d.decision.kind !== "allow");
+      if (denied) return denied;
+      return { decision: { kind: "allow" } };
+    }
+    if (compose === "any") {
+      const lastDeny = decisions.reverse().find((d) => d.decision.kind === "deny");
+      if (lastDeny) return lastDeny;
+      const lastDefer = decisions.find((d) => d.decision.kind === "defer");
+      if (lastDefer) return lastDefer;
+      return {
+        decision: { kind: "deny", reason: "any: no gate allowed" }
+      };
+    }
+    return { decision: { kind: "allow" } };
+  }
+  async function shouldDeferForGlobalPause(task) {
+    if (task.respectsGlobalPause === false) return { paused: false };
+    const pause = await deps.globalPause.current(now());
+    if (!pause.active) return { paused: false };
+    return {
+      paused: true,
+      reason: pause.reason ? `global_pause: ${pause.reason}` : "global_pause"
+    };
+  }
+  async function persist(task) {
+    const nextFireAtIso = await resolveNextFireAt(task);
+    await deps.store.upsert(task, { nextFireAtIso });
+    return structuredClone(task);
+  }
+  async function resolveNextFireAt(task) {
+    if (isTerminal(task.state.status)) return null;
+    const ownerFacts = await deps.ownerFacts();
+    return computeNextFireAt(task, {
+      now: now(),
+      ownerFacts,
+      anchors: deps.anchors
+    });
+  }
+  async function schedule(input) {
+    if (input.idempotencyKey) {
+      const existing = await deps.store.findByIdempotencyKey(
+        input.idempotencyKey
+      );
+      if (existing) return existing;
+    }
+    if (deps.channelKeys && input.escalation?.steps) {
+      const registered = deps.channelKeys();
+      for (const step of input.escalation.steps) {
+        if (!registered.has(step.channelKey)) {
+          throw new ChannelKeyError(
+            step.channelKey,
+            Array.from(registered).sort()
+          );
+        }
+      }
+    }
+    const withApprovalDefaults = applyApprovalCompletionDefault(input);
+    const initialState = {
+      status: "scheduled",
+      followupCount: 0
+    };
+    const task = {
+      taskId: newTaskId(),
+      ...withApprovalDefaults,
+      state: initialState
+    };
+    await persist(task);
+    await logger.log(task.taskId, "scheduled", {
+      detail: {
+        kind: task.kind,
+        priority: task.priority,
+        triggerKind: task.trigger.kind
+      }
+    });
+    if (task.completionCheck?.followupAfterMinutes && task.pipeline?.onSkip && task.pipeline.onSkip.length > 0) {
+      await logger.log(task.taskId, "edited", {
+        reason: "validation: pipeline.onSkip overrides completionCheck.followupAfterMinutes"
+      });
+    }
+    return task;
+  }
+  function applyApprovalCompletionDefault(input) {
+    if (input.kind !== "approval") return input;
+    const onSkipEmpty = !input.pipeline?.onSkip || input.pipeline.onSkip.length === 0;
+    if (!onSkipEmpty) return input;
+    if (input.completionCheck?.followupAfterMinutes !== void 0) return input;
+    const baseCheck = input.completionCheck ?? { kind: "user_acknowledged" };
+    return {
+      ...input,
+      completionCheck: {
+        ...baseCheck,
+        followupAfterMinutes: APPROVAL_DEFAULT_FOLLOWUP_AFTER_MINUTES
+      }
+    };
+  }
+  async function list(filter) {
+    return deps.store.list(filter);
+  }
+  async function applySnooze(task, payload) {
+    const minutes = payload?.minutes;
+    const untilIso = payload?.untilIso;
+    let newFireAtIso;
+    if (typeof untilIso === "string") {
+      newFireAtIso = new Date(untilIso).toISOString();
+    } else if (typeof minutes === "number" && minutes > 0) {
+      newFireAtIso = new Date(now().getTime() + minutes * 6e4).toISOString();
+    } else {
+      throw new Error("snooze: provide minutes or untilIso");
+    }
+    const reopenStatus = "scheduled";
+    task.state.status = reopenStatus;
+    task.state.firedAt = newFireAtIso;
+    task.state.lastDecisionLog = `snoozed until ${newFireAtIso} (ladder reset)`;
+    setEscalationCursor(task, resetLadderForSnooze(newFireAtIso));
+    await persist(task);
+    await logger.log(task.taskId, "snoozed", {
+      reason: `until ${newFireAtIso}`,
+      detail: { newFireAtIso }
+    });
+    return task;
+  }
+  async function applySkip(task, payload) {
+    task.state.status = "skipped";
+    task.state.lastDecisionLog = payload?.reason ?? "user skipped";
+    await persist(task);
+    await logger.log(task.taskId, "skipped", {
+      reason: payload?.reason ?? "user skipped"
+    });
+    await runPipeline(task, "skipped");
+    return task;
+  }
+  async function applyComplete(task, payload) {
+    task.state.status = "completed";
+    task.state.completedAt = now().toISOString();
+    task.state.lastDecisionLog = payload?.reason ?? "completed";
+    await persist(task);
+    await logger.log(task.taskId, "completed", { reason: payload?.reason });
+    await runPipeline(task, "completed");
+    return task;
+  }
+  async function applyDismiss(task, payload) {
+    task.state.status = "dismissed";
+    task.state.lastDecisionLog = payload?.reason ?? "dismissed";
+    await persist(task);
+    await logger.log(task.taskId, "dismissed", { reason: payload?.reason });
+    return task;
+  }
+  async function applyEscalate(task, payload) {
+    task.state.followupCount += 1;
+    task.state.lastFollowupAt = now().toISOString();
+    task.state.lastDecisionLog = "escalated";
+    await persist(task);
+    await logger.log(task.taskId, "escalated", {
+      reason: payload?.force ? "force=true" : void 0
+    });
+    return task;
+  }
+  async function applyAcknowledge(task) {
+    task.state.status = "acknowledged";
+    task.state.acknowledgedAt = now().toISOString();
+    task.state.lastDecisionLog = "acknowledged";
+    await persist(task);
+    await logger.log(task.taskId, "acknowledged");
+    return task;
+  }
+  async function applyEdit(task, payload) {
+    if (!payload) return task;
+    const banned = ["taskId", "state"];
+    for (const key of banned) {
+      if (key in payload) {
+        throw new Error(`edit: ${String(key)} is read-only`);
+      }
+    }
+    Object.assign(task, payload);
+    await persist(task);
+    await logger.log(task.taskId, "edited", {
+      detail: { keys: Object.keys(payload) }
+    });
+    return task;
+  }
+  async function applyReopen(task, payload) {
+    if (!isTerminal(task.state.status)) {
+      throw new Error(
+        `reopen: task ${task.taskId} is not in a terminal state (status=${task.state.status})`
+      );
+    }
+    const windowHours = (() => {
+      const raw = task.metadata?.reopenWindowHours;
+      return typeof raw === "number" && raw > 0 ? raw : 24;
+    })();
+    const referenceIso = task.state.lastFollowupAt ?? task.state.firedAt ?? task.state.completedAt ?? now().toISOString();
+    const expiresMs = new Date(referenceIso).getTime() + windowHours * 60 * 60 * 1e3;
+    if (now().getTime() > expiresMs) {
+      throw new Error(
+        `reopen: window expired (>${windowHours}h since ${referenceIso})`
+      );
+    }
+    task.state.status = "scheduled";
+    task.state.lastDecisionLog = payload?.reason ?? "reopened";
+    clearEscalationCursor(task);
+    await persist(task);
+    await logger.log(task.taskId, "reopened", { reason: payload?.reason });
+    return task;
+  }
+  async function apply(taskId, verb, payload) {
+    const task = await deps.store.get(taskId);
+    if (!task) {
+      throw new Error(`apply: task ${taskId} not found`);
+    }
+    switch (verb) {
+      case "snooze":
+        return applySnooze(
+          task,
+          payload
+        );
+      case "skip":
+        return applySkip(task, payload);
+      case "complete":
+        return applyComplete(task, payload);
+      case "dismiss":
+        return applyDismiss(task, payload);
+      case "escalate":
+        return applyEscalate(task, payload);
+      case "acknowledge":
+        return applyAcknowledge(task);
+      case "edit":
+        return applyEdit(
+          task,
+          payload
+        );
+      case "reopen":
+        return applyReopen(task, payload);
+      default: {
+        const exhaustive = verb;
+        throw new Error(`apply: unknown verb ${String(exhaustive)}`);
+      }
+    }
+  }
+  async function runPipeline(parent, outcome) {
+    const refs = (() => {
+      switch (outcome) {
+        case "completed":
+          return parent.pipeline?.onComplete;
+        case "skipped":
+          return parent.pipeline?.onSkip;
+        case "failed":
+          return parent.pipeline?.onFail;
+        // expired / dismissed do not propagate; pipeline.onSkip captures
+        // the user-skip case explicitly.
+        default:
+          return void 0;
+      }
+    })();
+    if (!refs || refs.length === 0) return [];
+    const created = [];
+    for (const ref of refs) {
+      if (typeof ref === "string") {
+        const child = await deps.store.get(ref);
+        if (child) {
+          child.state.pipelineParentId = parent.taskId;
+          await persist(child);
+          await logger.log(child.taskId, "edited", {
+            reason: `pipeline.${outcomeToFieldName(outcome)} parent=${parent.taskId}`
+          });
+          created.push(child);
+        }
+        continue;
+      }
+      const cloned = structuredClone(ref);
+      const childInput = stripServerManaged(cloned);
+      const fresh = await schedule(childInput);
+      fresh.state.pipelineParentId = parent.taskId;
+      await persist(fresh);
+      created.push(fresh);
+    }
+    return created;
+  }
+  function outcomeToFieldName(outcome) {
+    switch (outcome) {
+      case "completed":
+        return "onComplete";
+      case "skipped":
+        return "onSkip";
+      case "failed":
+        return "onFail";
+      default:
+        return outcome;
+    }
+  }
+  async function pipeline(taskId, outcome) {
+    const task = await deps.store.get(taskId);
+    if (!task) throw new Error(`pipeline: task ${taskId} not found`);
+    if (!isTerminal(task.state.status) && task.state.status !== outcome) {
+      task.state.status = outcome;
+      task.state.lastDecisionLog = `pipeline: ${outcome}`;
+      if (outcome === "completed" && !task.state.completedAt) {
+        task.state.completedAt = now().toISOString();
+      }
+      await persist(task);
+      await logger.log(task.taskId, outcomeToLogTransition(outcome), {
+        reason: `pipeline: ${outcome}`
+      });
+    }
+    return runPipeline(task, outcome);
+  }
+  function outcomeToLogTransition(outcome) {
+    return outcome;
+  }
+  async function fire(taskId, args) {
+    const result = await fireWithResult(taskId, args);
+    switch (result.kind) {
+      case "fired":
+      case "skipped":
+      case "dispatch_failed":
+        return result.task;
+      case "raced": {
+        const winner = await deps.store.get(result.taskId);
+        if (winner) return winner;
+        throw new Error(`fire: task ${result.taskId} not found after race`);
+      }
+      default: {
+        const _exhaustive = result;
+        throw new Error("fire: unreachable");
+      }
+    }
+  }
+  async function fireWithResult(taskId, args) {
+    const task = await deps.store.get(taskId);
+    if (!task) throw new Error(`fire: task ${taskId} not found`);
+    if (isTerminal(task.state.status)) {
+      const canRefire = args?.allowTerminalRefire === true && task.state.status !== "dismissed" && isRecurringTrigger(task.trigger);
+      if (!canRefire) {
+        return {
+          kind: "skipped",
+          task,
+          reason: `terminal:${task.state.status}`
+        };
+      }
+      task.state.status = "scheduled";
+      delete task.state.acknowledgedAt;
+      delete task.state.completedAt;
+      task.state.lastDecisionLog = "recurrence refire";
+      clearEscalationCursor(task);
+      await persist(task);
+    }
+    await logger.log(task.taskId, "fire_attempt", {
+      detail: { eventPayload: args?.eventPayload ? "present" : "absent" }
+    });
+    const pause = await shouldDeferForGlobalPause(task);
+    if (pause.paused) {
+      task.state.status = "skipped";
+      task.state.lastDecisionLog = pause.reason ?? "global_pause";
+      await persist(task);
+      await logger.log(task.taskId, "skipped", {
+        reason: pause.reason ?? "global_pause"
+      });
+      return {
+        kind: "skipped",
+        task,
+        reason: pause.reason ?? "global_pause"
+      };
+    }
+    const gateOutcome = await evaluateGates(task);
+    if (gateOutcome.decision.kind === "deny") {
+      task.state.status = "skipped";
+      task.state.lastDecisionLog = `${gateOutcome.gateKind ?? "gate"}: ${gateOutcome.decision.reason}`;
+      await persist(task);
+      await logger.log(task.taskId, "skipped", {
+        reason: task.state.lastDecisionLog
+      });
+      await runPipeline(task, "skipped");
+      return {
+        kind: "skipped",
+        task,
+        reason: task.state.lastDecisionLog
+      };
+    }
+    if (gateOutcome.decision.kind === "defer") {
+      const offset = "offsetMinutes" in gateOutcome.decision.until ? gateOutcome.decision.until.offsetMinutes : Math.max(
+        1,
+        Math.round(
+          (new Date(gateOutcome.decision.until.atIso).getTime() - now().getTime()) / 6e4
+        )
+      );
+      task.state.lastDecisionLog = `${gateOutcome.gateKind ?? "gate"}: deferred ${offset}m (${gateOutcome.decision.reason})`;
+      const newFireMs = now().getTime() + offset * 6e4;
+      task.state.firedAt = new Date(newFireMs).toISOString();
+      await persist(task);
+      await logger.log(task.taskId, "snoozed", {
+        reason: `gate-defer: ${gateOutcome.decision.reason}`,
+        detail: { offsetMinutes: offset }
+      });
+      return {
+        kind: "skipped",
+        task,
+        reason: `gate-defer:${gateOutcome.decision.reason}`
+      };
+    }
+    const fireAtIso = now().toISOString();
+    const claim = await deps.store.claimForFire({
+      taskId: task.taskId,
+      firedAtIso: fireAtIso
+    });
+    if (claim.kind === "raced") {
+      return { kind: "raced", taskId: task.taskId };
+    }
+    const claimed = claim.task;
+    claimed.state.lastDecisionLog = "fired";
+    setEscalationCursor(claimed, {
+      stepIndex: -1,
+      lastDispatchedAt: fireAtIso
+    });
+    await persist(claimed);
+    await logger.log(claimed.taskId, "fired");
+    const hostCaps = deps.hostCapabilities?.() ?? ALL_PROFILES_AVAILABLE;
+    const taskProfile = claimed.executionProfile ?? DEFAULT_TASK_EXECUTION_PROFILE;
+    const substituted = !hostCaps.has(taskProfile);
+    const dispatchChannelKey = substituted ? "in_app" : pickChannelKey(claimed);
+    if (substituted) {
+      await logger.log(claimed.taskId, "substituted", {
+        reason: "host_incapable",
+        detail: {
+          originalProfile: taskProfile,
+          substituteProfile: "notify-only",
+          availableProfiles: Array.from(hostCaps)
+        }
+      });
+    }
+    let dispatchResult;
+    try {
+      dispatchResult = await dispatcher.dispatch({
+        taskId: claimed.taskId,
+        firedAtIso: fireAtIso,
+        channelKey: dispatchChannelKey,
+        intensity: pickIntensity(claimed),
+        promptInstructions: claimed.promptInstructions,
+        contextRequest: claimed.contextRequest,
+        output: claimed.output
+      });
+    } catch (error) {
+      const wrapped = error instanceof Error ? error : new Error(String(error));
+      const reason = `dispatch_failed: ${wrapped.message}`;
+      claimed.state.status = "failed";
+      claimed.state.lastDecisionLog = reason;
+      claimed.metadata = {
+        ...claimed.metadata ?? {},
+        lastDispatchError: {
+          name: wrapped.name,
+          message: wrapped.message
+        }
+      };
+      await persist(claimed);
+      await logger.log(claimed.taskId, "failed", {
+        reason,
+        detail: {
+          errorName: wrapped.name,
+          message: wrapped.message
+        }
+      });
+      await runPipeline(claimed, "failed");
+      return { kind: "dispatch_failed", task: claimed, error: wrapped };
+    }
+    if (dispatchResult) {
+      claimed.metadata = {
+        ...claimed.metadata ?? {},
+        lastDispatchResult: dispatchResult
+      };
+      await persist(claimed);
+    }
+    return { kind: "fired", task: claimed };
+  }
+  function pickChannelKey(task) {
+    if (task.output?.destination === "channel" && typeof task.output.target === "string") {
+      const [channelKey] = task.output.target.split(":", 1);
+      if (channelKey) return channelKey;
+    }
+    if (task.escalation?.steps && task.escalation.steps.length > 0) {
+      return task.escalation.steps[0]?.channelKey ?? "in_app";
+    }
+    return "in_app";
+  }
+  function pickIntensity(task) {
+    if (task.priority === "high") return "urgent";
+    if (task.priority === "medium") return "normal";
+    return "soft";
+  }
+  async function evaluateCompletion(taskId, signal) {
+    const task = await deps.store.get(taskId);
+    if (!task) throw new Error(`evaluateCompletion: task ${taskId} not found`);
+    if (!task.completionCheck) return task;
+    const contrib = deps.completionChecks.get(task.completionCheck.kind);
+    if (!contrib) return task;
+    const ownerFacts = await deps.ownerFacts();
+    const ctx = {
+      task,
+      nowIso: now().toISOString(),
+      ownerFacts,
+      activity: deps.activity,
+      subjectStore: deps.subjectStore,
+      acknowledged: signal.acknowledged === true,
+      repliedSinceFiredAt: signal.repliedAtIso ? { atIso: signal.repliedAtIso } : void 0
+    };
+    const completed = await contrib.shouldComplete(task, ctx);
+    if (!completed) return task;
+    return applyComplete(task, { reason: `completion-check:${contrib.kind}` });
+  }
+  async function rolloverStateLog(opts) {
+    const days = opts?.retentionDays ?? 90;
+    const olderThanIso = new Date(
+      now().getTime() - days * 24 * 60 * 60 * 1e3
+    ).toISOString();
+    return deps.logStore.rollupOlderThan({
+      agentId: deps.agentId,
+      olderThanIso
+    });
+  }
+  function inspectRegistries() {
+    return {
+      gates: deps.gates.list().map((g) => g.kind),
+      completionChecks: deps.completionChecks.list().map((c) => c.kind),
+      ladders: deps.ladders.list().map((l) => l.ladderKey),
+      anchors: deps.anchors.list().map((a) => a.anchorKey),
+      consolidationPolicies: deps.consolidation.list().map((p) => p.anchorKey)
+    };
+  }
+  async function getEscalationCursor(taskId) {
+    const task = await deps.store.get(taskId);
+    if (!task) return null;
+    const raw = task.metadata?.escalationCursor;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+    const cursor = raw;
+    if (typeof cursor.stepIndex !== "number" || typeof cursor.lastDispatchedAt !== "string") {
+      return null;
+    }
+    const ladder = resolveEffectiveLadder(task, deps.ladders);
+    const stepIndex = cursor.stepIndex;
+    const channelKey = stepIndex >= 0 && stepIndex < ladder.steps.length ? ladder.steps[stepIndex]?.channelKey ?? "in_app" : ladder.steps[0]?.channelKey ?? "in_app";
+    return {
+      stepIndex,
+      lastFiredAt: cursor.lastDispatchedAt,
+      channelKey
+    };
+  }
+  return {
+    schedule,
+    list,
+    apply,
+    pipeline,
+    fire,
+    fireWithResult,
+    evaluateCompletion,
+    rolloverStateLog,
+    inspectRegistries,
+    getEscalationCursor
+  };
+}
+export {
+  ChannelKeyError,
+  TestNoopScheduledTaskDispatcher,
+  createInMemoryScheduledTaskStore,
+  createScheduledTaskRunner
+};
+//# sourceMappingURL=runner.js.map