@elizaos/agent 2.0.0-beta.2 → 2.0.11-beta.6

package/test-utils/sqlite-compat.js

@@ -0,0 +1,214 @@
+import { spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync, unlinkSync } from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+const require = createRequire(import.meta.url);
+let DatabaseSyncValue;
+let hasSqliteValue = false;
+const BUN_SQLITE_BRIDGE_SCRIPT = `
+import { Database } from "bun:sqlite";
+
+const payload = JSON.parse(await Bun.stdin.text());
+
+function reviveSqliteValue(value) {
+  if (value && typeof value === "object") {
+    if (value.__sqliteType === "bigint") {
+      return BigInt(value.value);
+    }
+    if (value.__sqliteType === "uint8array") {
+      return new Uint8Array(value.value);
+    }
+  }
+  return value;
+}
+
+function replaceSqliteValue(_key, value) {
+  if (typeof value === "bigint") {
+    const asNumber = Number(value);
+    return Number.isSafeInteger(asNumber) ? asNumber : value.toString();
+  }
+  if (value instanceof Uint8Array) {
+    return Array.from(value);
+  }
+  return value;
+}
+
+const db = new Database(payload.filename);
+
+try {
+  let result = null;
+  if (payload.operation === "exec") {
+    db.exec(payload.sql);
+  } else {
+    const params = payload.params.map(reviveSqliteValue);
+    const query = db.query(payload.sql);
+    if (payload.operation === "all") {
+      result = query.all(...params);
+    } else if (payload.operation === "get") {
+      result = query.get(...params) ?? null;
+    } else if (payload.operation === "run") {
+      result = query.run(...params);
+    }
+  }
+  process.stdout.write(JSON.stringify({ ok: true, result }, replaceSqliteValue));
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const stack = error instanceof Error ? error.stack : undefined;
+  process.stdout.write(JSON.stringify({ ok: false, error: { message, stack } }));
+  process.exitCode = 1;
+} finally {
+  db.close();
+}
+`;
+function isBunRuntime() {
+    return (typeof process !== "undefined" && typeof process.versions.bun === "string");
+}
+function hasBunCli() {
+    const result = spawnSync("bun", ["--version"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    return !result.error && result.status === 0;
+}
+function serializeSqliteValue(value) {
+    if (typeof value === "bigint") {
+        return { __sqliteType: "bigint", value: value.toString() };
+    }
+    if (value instanceof Uint8Array) {
+        return { __sqliteType: "uint8array", value: Array.from(value) };
+    }
+    return value;
+}
+function runBunSqliteCli(payload) {
+    const result = spawnSync("bun", ["--eval", BUN_SQLITE_BRIDGE_SCRIPT], {
+        encoding: "utf8",
+        input: JSON.stringify(payload),
+        maxBuffer: 50 * 1024 * 1024,
+    });
+    const stdout = result.stdout.trim();
+    let response;
+    if (stdout.length > 0) {
+        try {
+            response = JSON.parse(stdout);
+        }
+        catch {
+            const detail = result.stderr.trim() || stdout;
+            throw new Error(`[sqlite-compat] Could not parse Bun SQLite output: ${detail}`);
+        }
+    }
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status !== 0 || response?.ok === false || !response) {
+        const message = response?.ok === false
+            ? response.error.message
+            : result.stderr.trim() ||
+                `Bun SQLite bridge exited with status ${result.status ?? "unknown"}`;
+        throw new Error(`[sqlite-compat] ${message}`);
+    }
+    return response.result;
+}
+class BunCliDatabaseSyncCompat {
+    filename;
+    deleteOnClose;
+    constructor(filename) {
+        this.deleteOnClose = filename === ":memory:";
+        this.filename = this.deleteOnClose
+            ? join(tmpdir(), `eliza-sqlite-${process.pid}-${randomUUID()}.sqlite`)
+            : filename;
+    }
+    exec(sql) {
+        runBunSqliteCli({
+            filename: this.filename,
+            operation: "exec",
+            sql,
+            params: [],
+        });
+    }
+    prepare(sql) {
+        return {
+            all: (...params) => runBunSqliteCli({
+                filename: this.filename,
+                operation: "all",
+                sql,
+                params: params.map(serializeSqliteValue),
+            }),
+            get: (...params) => runBunSqliteCli({
+                filename: this.filename,
+                operation: "get",
+                sql,
+                params: params.map(serializeSqliteValue),
+            }),
+            run: (...params) => runBunSqliteCli({
+                filename: this.filename,
+                operation: "run",
+                sql,
+                params: params.map(serializeSqliteValue),
+            }),
+        };
+    }
+    close() {
+        if (!this.deleteOnClose) {
+            return;
+        }
+        for (const filename of [
+            this.filename,
+            `${this.filename}-shm`,
+            `${this.filename}-wal`,
+        ]) {
+            if (existsSync(filename)) {
+                unlinkSync(filename);
+            }
+        }
+    }
+}
+try {
+    ({ DatabaseSync: DatabaseSyncValue } = require("node:sqlite"));
+    hasSqliteValue = typeof DatabaseSyncValue === "function";
+}
+catch {
+    DatabaseSyncValue = undefined;
+}
+if (!hasSqliteValue) {
+    if (isBunRuntime()) {
+        try {
+            const { Database } = require("bun:sqlite");
+            class BunDatabaseSyncCompat {
+                db;
+                constructor(filename) {
+                    this.db = new Database(filename);
+                }
+                exec(sql) {
+                    this.db.exec(sql);
+                }
+                prepare(sql) {
+                    const query = this.db.query(sql);
+                    return {
+                        all: (...params) => query.all(...params),
+                        get: (...params) => query.get(...params) ?? null,
+                        run: (...params) => query.run(...params),
+                    };
+                }
+                close() {
+                    this.db.close();
+                }
+            }
+            DatabaseSyncValue = BunDatabaseSyncCompat;
+            hasSqliteValue = true;
+        }
+        catch {
+            hasSqliteValue = false;
+        }
+    }
+    else if (hasBunCli()) {
+        DatabaseSyncValue = BunCliDatabaseSyncCompat;
+        hasSqliteValue = true;
+    }
+    else {
+        hasSqliteValue = false;
+    }
+}
+export const hasSqlite = hasSqliteValue;
+export const DatabaseSync = DatabaseSyncValue;

package/triggers/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/triggers/runtime.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAW,IAAI,EAAQ,MAAM,eAAe,CAAC;AAOxE,OAAO,KAAK,EACV,aAAa,EACb,qBAAqB,EACrB,gBAAgB,EAChB,cAAc,EAEf,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,iBAAiB,EAAG,kBAA2B,CAAC;AAC7D,eAAO,MAAM,iBAAiB,yCAA0C,CAAC;AAYzE,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,WAAW,GAAG,QAAQ,GAAG,OAAO,CAAC;IACzC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE;QACN,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACnC,CAAC;CACH;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;IACxC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;IAGhC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAoED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,aAAa,GAAG,IAAI,CAOlE;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,gBAAgB,EAAE,CAG9D;AAED,wBAAgB,sBAAsB,CAAC,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAavE;AAED,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,aAAa,GAAG,MAAM,CAa/D;AAqED,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,aAAa,EACtB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,sBAAsB,CAAC,CA8NjC;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAkBtE;AAED,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,IAAI,EAAE,CAAC,CAwBjB;AAkED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,GAAG,cAAc,GAAG,IAAI,CAqCtE;AAED,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,qBAAqB,CAAC,CAsChC"}

package/triggers/runtime.js

@@ -0,0 +1,482 @@
+import crypto from "node:crypto";
+import { ServiceType, stringToUuid } from "@elizaos/core";
+import { buildTriggerMetadata, DISABLED_TRIGGER_INTERVAL_MS, MAX_TRIGGER_RUN_HISTORY, } from "./scheduling.js";
+export const TRIGGER_TASK_NAME = "TRIGGER_DISPATCH";
+export const TRIGGER_TASK_TAGS = ["queue", "repeat", "trigger"];
+const HEARTBEAT_TASK_TAGS = ["queue", "repeat", "heartbeat"];
+const DEFAULT_MAX_ACTIVE_TRIGGERS = 100;
+function getNotifier(runtime) {
+    const svc = runtime.getService(ServiceType.NOTIFICATION);
+    return svc && typeof svc.notify === "function" ? svc : null;
+}
+const metricsByAgent = new Map();
+function getMetrics(agentId) {
+    const current = metricsByAgent.get(agentId);
+    if (current)
+        return current;
+    const created = {
+        totalExecutions: 0,
+        totalFailures: 0,
+        totalSkipped: 0,
+    };
+    metricsByAgent.set(agentId, created);
+    return created;
+}
+function recordExecutionMetric(agentId, status, ts) {
+    const metrics = getMetrics(agentId);
+    if (status === "success" || status === "error") {
+        metrics.totalExecutions += 1;
+        metrics.lastExecutionAt = ts;
+    }
+    if (status === "error") {
+        metrics.totalFailures += 1;
+    }
+    if (status === "skipped") {
+        metrics.totalSkipped += 1;
+    }
+}
+function appendRunRecord(existing, record) {
+    const runs = [...(existing ?? []), record];
+    return runs.length <= MAX_TRIGGER_RUN_HISTORY
+        ? runs
+        : runs.slice(runs.length - MAX_TRIGGER_RUN_HISTORY);
+}
+function taskMetadata(task) {
+    return (task.metadata ?? {});
+}
+export function readTriggerConfig(task) {
+    const trigger = taskMetadata(task).trigger;
+    if (!trigger || typeof trigger !== "object" || Array.isArray(trigger))
+        return null;
+    return trigger.triggerId
+        ? trigger
+        : null;
+}
+export function readTriggerRuns(task) {
+    const runs = taskMetadata(task).triggerRuns;
+    return Array.isArray(runs) ? runs : [];
+}
+export function triggersFeatureEnabled(runtime) {
+    const runtimeSetting = runtime?.getSetting("ELIZA_TRIGGERS_ENABLED");
+    if (runtimeSetting === false ||
+        runtimeSetting === "false" ||
+        runtimeSetting === "0") {
+        return false;
+    }
+    const env = process.env.ELIZA_TRIGGERS_ENABLED;
+    if (!env)
+        return true;
+    const normalized = env.trim().toLowerCase();
+    return normalized !== "0" && normalized !== "false";
+}
+export function getTriggerLimit(runtime) {
+    const runtimeSetting = runtime?.getSetting("ELIZA_TRIGGERS_MAX_ACTIVE");
+    if (typeof runtimeSetting === "number" && Number.isFinite(runtimeSetting)) {
+        return Math.max(1, Math.floor(runtimeSetting));
+    }
+    if (typeof runtimeSetting === "string" && /^\d+$/.test(runtimeSetting)) {
+        return Math.max(1, Number(runtimeSetting));
+    }
+    const env = process.env.ELIZA_TRIGGERS_MAX_ACTIVE;
+    if (env && /^\d+$/.test(env)) {
+        return Math.max(1, Number(env));
+    }
+    return DEFAULT_MAX_ACTIVE_TRIGGERS;
+}
+/**
+ * Read the idempotency key the task metadata carries for this trigger
+ * fire. armSchedules / rehydrateSchedules write a minute-bucketed key
+ * onto the metadata so dispatch can short-circuit duplicate fires.
+ */
+function readTaskIdempotencyKey(task) {
+    const meta = task.metadata;
+    const key = meta?.idempotencyKey;
+    return typeof key === "string" && key.length > 0 ? key : undefined;
+}
+async function dispatchWorkflow(runtime, task, trigger, event) {
+    if (!trigger.workflowId) {
+        return { ok: false, error: "workflow trigger missing workflowId" };
+    }
+    const svc = runtime.getService("WORKFLOW_DISPATCH");
+    if (!svc) {
+        runtime.logger.warn({
+            src: "trigger-runtime",
+            triggerId: trigger.triggerId,
+            workflowId: trigger.workflowId,
+        }, "[triggers] workflow dispatch requested but WORKFLOW_DISPATCH service not registered");
+        return { ok: false, error: "WORKFLOW_DISPATCH service not registered" };
+    }
+    const idempotencyKey = readTaskIdempotencyKey(task);
+    const payload = event
+        ? {
+            eventKind: event.kind,
+            eventPayload: event.payload ?? {},
+        }
+        : {};
+    const result = await svc.execute(trigger.workflowId, payload, {
+        idempotencyKey,
+    });
+    return result.ok
+        ? { ok: true, executionId: result.executionId }
+        : { ok: false, error: result.error ?? "workflow execution failed" };
+}
+export async function executeTriggerTask(runtime, task, options) {
+    if (!task.id) {
+        return { status: "skipped", taskDeleted: false };
+    }
+    const trigger = readTriggerConfig(task);
+    if (!trigger) {
+        recordExecutionMetric(runtime.agentId, "skipped", Date.now());
+        return { status: "skipped", taskDeleted: false };
+    }
+    if (!trigger.enabled && !options.force) {
+        recordExecutionMetric(runtime.agentId, "skipped", Date.now());
+        return { status: "skipped", taskDeleted: false };
+    }
+    if (options.source === "event" &&
+        trigger.triggerType !== "event" &&
+        !options.force) {
+        recordExecutionMetric(runtime.agentId, "skipped", Date.now());
+        return { status: "skipped", taskDeleted: false };
+    }
+    if (options.source === "event" &&
+        trigger.triggerType === "event" &&
+        trigger.eventKind !== options.event?.kind &&
+        !options.force) {
+        recordExecutionMetric(runtime.agentId, "skipped", Date.now());
+        return { status: "skipped", taskDeleted: false };
+    }
+    if (typeof trigger.maxRuns === "number" &&
+        trigger.maxRuns > 0 &&
+        trigger.runCount >= trigger.maxRuns) {
+        await runtime.deleteTask(task.id);
+        recordExecutionMetric(runtime.agentId, "skipped", Date.now());
+        return {
+            status: "skipped",
+            taskDeleted: true,
+            trigger: taskToTriggerSummary(task),
+        };
+    }
+    if (trigger.kind !== "workflow") {
+        runtime.logger.warn({
+            src: "trigger-runtime",
+            taskId: task.id,
+            triggerId: trigger.triggerId,
+            kind: trigger.kind,
+        }, "Trigger is not workflow-kind; skipping");
+        recordExecutionMetric(runtime.agentId, "skipped", Date.now());
+        return { status: "skipped", taskDeleted: false };
+    }
+    const startedAt = Date.now();
+    let status = "success";
+    let errorMessage = "";
+    let workflowExecutionId;
+    const result = await dispatchWorkflow(runtime, task, trigger, options.event);
+    if (result.ok === true) {
+        workflowExecutionId = result.executionId;
+    }
+    else {
+        status = "error";
+        errorMessage = result.error;
+        runtime.logger.error({
+            src: "trigger-runtime",
+            agentId: runtime.agentId,
+            taskId: task.id,
+            triggerId: trigger.triggerId,
+            workflowId: trigger.workflowId,
+            error: errorMessage,
+        }, "Workflow trigger dispatch failed");
+        // Scheduled automations run without the user in the chat loop, so a
+        // dispatch failure is otherwise invisible. Surface it on the notification
+        // rail (fire-and-forget; never let a notify failure mask the trigger error).
+        void getNotifier(runtime)
+            ?.notify({
+            title: `Automation "${trigger.displayName}" failed`,
+            body: errorMessage.slice(0, 200),
+            category: "workflow",
+            priority: "high",
+            source: "trigger",
+            groupKey: `trigger:${task.id ?? trigger.triggerId}`,
+            data: { taskId: task.id, triggerId: trigger.triggerId, error: errorMessage },
+        })
+            .catch(() => { });
+    }
+    if (status === "success") {
+        runtime.logger.info({
+            src: "trigger-runtime",
+            triggerId: trigger.triggerId,
+            triggerName: trigger.displayName,
+            triggerType: trigger.triggerType,
+            source: options.source,
+            latencyMs: Date.now() - startedAt,
+        }, `Trigger "${trigger.displayName}" executed successfully`);
+    }
+    const finishedAt = Date.now();
+    const runRecord = {
+        triggerRunId: stringToUuid(crypto.randomUUID()),
+        triggerId: trigger.triggerId,
+        taskId: task.id,
+        startedAt,
+        finishedAt,
+        status,
+        error: errorMessage || undefined,
+        latencyMs: finishedAt - startedAt,
+        source: options.source,
+        eventKind: options.event?.kind,
+    };
+    const updatedTrigger = {
+        ...trigger,
+        runCount: trigger.runCount + 1,
+        lastRunAtIso: new Date(finishedAt).toISOString(),
+        lastStatus: status,
+        lastError: errorMessage || undefined,
+    };
+    const shouldDeleteTask = updatedTrigger.triggerType === "once" ||
+        (typeof updatedTrigger.maxRuns === "number" &&
+            updatedTrigger.maxRuns > 0 &&
+            updatedTrigger.runCount >= updatedTrigger.maxRuns);
+    const existingMetadata = taskMetadata(task);
+    const nextMetadata = buildTriggerMetadata({
+        existingMetadata,
+        trigger: updatedTrigger,
+        nowMs: finishedAt,
+    });
+    let metadataToPersist;
+    if (!nextMetadata) {
+        metadataToPersist = {
+            ...existingMetadata,
+            updatedAt: finishedAt,
+            updateInterval: DISABLED_TRIGGER_INTERVAL_MS,
+            trigger: {
+                ...updatedTrigger,
+                enabled: false,
+                nextRunAtMs: finishedAt + DISABLED_TRIGGER_INTERVAL_MS,
+                lastError: updatedTrigger.lastError ?? "Failed to compute next trigger schedule",
+            },
+            triggerRuns: appendRunRecord(existingMetadata.triggerRuns, runRecord),
+        };
+    }
+    else {
+        metadataToPersist = {
+            ...nextMetadata,
+            triggerRuns: appendRunRecord(existingMetadata.triggerRuns, runRecord),
+        };
+    }
+    // Refresh the idempotency key for the next fire so a re-run within the
+    // same minute window collapses at dispatch. The schedule-arming layer
+    // (`armSchedules`) seeds the initial key with the same formula.
+    if (metadataToPersist.trigger?.kind === "workflow" &&
+        metadataToPersist.trigger.workflowId &&
+        typeof metadataToPersist.trigger.nextRunAtMs === "number") {
+        const minuteBucket = Math.floor(metadataToPersist.trigger.nextRunAtMs / 60_000);
+        metadataToPersist.idempotencyKey = `${metadataToPersist.trigger.workflowId}:${minuteBucket}`;
+    }
+    else {
+        delete metadataToPersist.idempotencyKey;
+    }
+    await runtime.updateTask(task.id, {
+        description: metadataToPersist.trigger?.displayName ?? task.description,
+        metadata: metadataToPersist,
+    });
+    const updatedTask = {
+        ...task,
+        description: metadataToPersist.trigger?.displayName ?? task.description,
+        metadata: metadataToPersist,
+    };
+    const triggerSummary = taskToTriggerSummary(updatedTask);
+    if (shouldDeleteTask) {
+        await runtime.deleteTask(task.id);
+        recordExecutionMetric(runtime.agentId, status, finishedAt);
+        return {
+            status,
+            error: errorMessage || undefined,
+            runRecord,
+            taskDeleted: true,
+            trigger: triggerSummary,
+            executionId: workflowExecutionId,
+        };
+    }
+    recordExecutionMetric(runtime.agentId, status, finishedAt);
+    return {
+        status,
+        error: errorMessage || undefined,
+        runRecord,
+        taskDeleted: false,
+        trigger: triggerSummary,
+        executionId: workflowExecutionId,
+    };
+}
+export function registerTriggerTaskWorker(runtime) {
+    if (runtime.getTaskWorker(TRIGGER_TASK_NAME))
+        return;
+    runtime.registerTaskWorker({
+        name: TRIGGER_TASK_NAME,
+        shouldRun: async () => true,
+        execute: async (rt, options, task) => {
+            // Return the full result so callers (tests, dashboards) can inspect
+            // trigger-specific fields like taskDeleted and runRecord.
+            // TaskWorker.execute is typed as returning only scheduling metadata; trigger
+            // workers return TriggerExecutionResult for tests and dashboards.
+            await executeTriggerTask(rt, task, {
+                source: options.source === "manual" ? "manual" : "scheduler",
+                force: options.force === true,
+            });
+            return undefined;
+        },
+    });
+}
+export async function listTriggerTasks(runtime) {
+    if (!triggersFeatureEnabled(runtime))
+        return [];
+    const agentIds = [runtime.agentId];
+    const [triggerTasks, heartbeatTasks] = await Promise.all([
+        runtime.getTasks({
+            agentIds,
+            tags: ["repeat", "trigger"],
+        }),
+        runtime.getTasks({
+            agentIds,
+            tags: ["repeat", "heartbeat"],
+        }),
+    ]);
+    const merged = new Map();
+    for (const task of [...triggerTasks, ...heartbeatTasks]) {
+        const key = task.id ??
+            `${task.name}:${task.description ?? ""}:${(task.tags ?? []).join(",")}`;
+        if (!merged.has(key)) {
+            merged.set(key, task);
+        }
+    }
+    return [...merged.values()];
+}
+function isExplicitHeartbeatTask(task) {
+    const tags = task.tags ?? [];
+    return HEARTBEAT_TASK_TAGS.every((tag) => tags.includes(tag));
+}
+/**
+ * Derive a friendly display name for a plugin-owned repeat task that
+ * doesn't carry explicit trigger metadata. Prefers the task's own
+ * `name` (e.g. "IMESSAGE_HEARTBEAT") humanized, then falls back to the
+ * first non-generic tag ("imessage", "telegram", etc.), then to a
+ * generic "System Heartbeat" label.
+ */
+function deriveSystemHeartbeatName(task) {
+    if (task.name && task.name.length > 0) {
+        return task.name
+            .replace(/_/g, " ")
+            .toLowerCase()
+            .replace(/\b\w/g, (c) => c.toUpperCase());
+    }
+    const tag = (task.tags ?? []).find((t) => t !== "queue" && t !== "repeat" && t !== "trigger");
+    if (tag) {
+        return `${tag.charAt(0).toUpperCase()}${tag.slice(1)} Heartbeat`;
+    }
+    return "System Heartbeat";
+}
+/**
+ * Synthesize a read-only TriggerSummary for an explicit heartbeat task
+ * that Eliza's trigger schema doesn't fully own. This is narrower than
+ * "any repeat task": internal queue drains and runtime schedulers should
+ * stay out of the Heartbeats UI even though they also use repeat tasks.
+ */
+function synthesizeSystemHeartbeatSummary(task) {
+    if (!task.id)
+        return null;
+    const metadata = taskMetadata(task);
+    const intervalMs = typeof metadata.updateInterval === "number"
+        ? metadata.updateInterval
+        : undefined;
+    const tags = task.tags ?? [];
+    // Identify the owning plugin from the third tag (first two are "queue"
+    // and "repeat"). This becomes createdBy so the UI can group by source.
+    const createdBy = tags.find((t) => t !== "queue" && t !== "repeat" && t !== "trigger") ??
+        "system";
+    return {
+        id: task.id,
+        taskId: task.id,
+        displayName: deriveSystemHeartbeatName(task),
+        instructions: task.description ?? "",
+        triggerType: "interval",
+        enabled: true,
+        wakeMode: "next_autonomy_cycle",
+        createdBy,
+        intervalMs,
+        runCount: 0,
+        updatedAt: typeof metadata.updatedAt === "number" ? metadata.updatedAt : undefined,
+        updateInterval: intervalMs,
+    };
+}
+export function taskToTriggerSummary(task) {
+    const trigger = readTriggerConfig(task);
+    if (trigger && task.id) {
+        const metadata = taskMetadata(task);
+        return {
+            id: trigger.triggerId,
+            taskId: task.id,
+            displayName: trigger.displayName,
+            instructions: trigger.instructions,
+            triggerType: trigger.triggerType,
+            enabled: trigger.enabled,
+            wakeMode: trigger.wakeMode,
+            createdBy: trigger.createdBy,
+            timezone: trigger.timezone,
+            intervalMs: trigger.intervalMs,
+            scheduledAtIso: trigger.scheduledAtIso,
+            cronExpression: trigger.cronExpression,
+            eventKind: trigger.eventKind,
+            maxRuns: trigger.maxRuns,
+            runCount: trigger.runCount,
+            nextRunAtMs: trigger.nextRunAtMs,
+            lastRunAtIso: trigger.lastRunAtIso,
+            lastStatus: trigger.lastStatus,
+            lastError: trigger.lastError,
+            updatedAt: metadata.updatedAt,
+            updateInterval: metadata.updateInterval,
+            kind: trigger.kind,
+            workflowId: trigger.workflowId,
+            workflowName: trigger.workflowName,
+        };
+    }
+    if (isExplicitHeartbeatTask(task)) {
+        return synthesizeSystemHeartbeatSummary(task);
+    }
+    return null;
+}
+export async function getTriggerHealthSnapshot(runtime) {
+    const tasks = await listTriggerTasks(runtime);
+    let activeTriggers = 0;
+    let disabledTriggers = 0;
+    let durableExecutions = 0;
+    let durableFailures = 0;
+    let durableLastExecAt;
+    for (const task of tasks) {
+        const trigger = readTriggerConfig(task);
+        if (!trigger)
+            continue;
+        if (trigger.enabled) {
+            activeTriggers += 1;
+        }
+        else {
+            disabledTriggers += 1;
+        }
+        const runs = readTriggerRuns(task);
+        for (const run of runs) {
+            durableExecutions += 1;
+            if (run.status === "error")
+                durableFailures += 1;
+            if (!durableLastExecAt || run.finishedAt > durableLastExecAt) {
+                durableLastExecAt = run.finishedAt;
+            }
+        }
+    }
+    const inMemory = getMetrics(runtime.agentId);
+    return {
+        triggersEnabled: triggersFeatureEnabled(runtime),
+        activeTriggers,
+        disabledTriggers,
+        totalExecutions: Math.max(inMemory.totalExecutions, durableExecutions),
+        totalFailures: Math.max(inMemory.totalFailures, durableFailures),
+        totalSkipped: inMemory.totalSkipped,
+        lastExecutionAt: inMemory.lastExecutionAt ?? durableLastExecAt,
+    };
+}