volute 0.49.0 → 0.51.0

package/dist/chunk-ICL6T4SN.js

@@ -0,0 +1,562 @@
+#!/usr/bin/env node
+import {
+  publish
+} from "./chunk-LNNI3MS4.js";
+import {
+  logger_default
+} from "./chunk-QUSMYGNQ.js";
+import {
+  findMind,
+  getBaseName,
+  getDb
+} from "./chunk-H6X6CKDN.js";
+import {
+  mindHistory,
+  systemEvents,
+  turns
+} from "./chunk-2RNMBXD2.js";
+
+// packages/daemon/src/lib/chat/system-events.ts
+import { and, asc, desc, eq, gt, isNull, lte, or, sql } from "drizzle-orm";
+
+// packages/daemon/src/lib/util/session-name.ts
+function newEphemeralSession() {
+  return `new-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+// packages/daemon/src/lib/chat/system-events.ts
+var elog = logger_default.child("system-events");
+var MIND_LEVEL_THREAD = "";
+var MAX_NEXT_TURN_EVENTS = 100;
+var FLUSH_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+function parseMeta(meta, context) {
+  if (!meta) return {};
+  try {
+    return JSON.parse(meta);
+  } catch (err) {
+    elog.error(`corrupt event meta${context ? ` (${context})` : ""}: ${meta}`, logger_default.errorData(err));
+    return {};
+  }
+}
+function eventLabel(type, meta) {
+  const m = meta ?? {};
+  const s = (k) => typeof m[k] === "string" ? m[k] : void 0;
+  switch (type) {
+    case "schedule":
+      return s("scheduleId") ? `Schedule: ${s("scheduleId")}` : "Schedule";
+    case "sleep":
+      return "Time to rest";
+    case "wake":
+      return "Woke from sleep";
+    case "lifecycle":
+      switch (s("subtype")) {
+        case "merge":
+          return "Variant merged in";
+        case "split":
+          return "Split into a variant";
+        case "variant-created":
+          return "Variant split off";
+        case "sprout":
+          return "Sprouted";
+        case "upgrade":
+          return "Framework upgraded";
+        case "restart":
+          return "Server restarted";
+        case "farewell":
+          return "Farewell before merge";
+        case "sprout-welcome":
+          return "A mind sprouted";
+        default:
+          return "Lifecycle";
+      }
+    case "orientation":
+      return "Orientation";
+    case "budget":
+      return "Token budget";
+    case "version":
+      return "New version available";
+    case "channel":
+      return "Channel invite";
+    case "file-share":
+      return "File offered";
+    case "webhook":
+      return s("source") ? `Webhook: ${s("source")}` : "Webhook";
+    case "notice":
+      switch (s("subtype")) {
+        case "crash":
+          return "Crash notice";
+        case "turn_error":
+          return "Turn error";
+        case "startup":
+          return "Startup notice";
+        case "extension":
+          return s("reason") ? `Notice: ${s("reason")}` : "Notice";
+        case "delivery_failed":
+          return "Delivery failed";
+        default:
+          return "Notice";
+      }
+    default:
+      return type.charAt(0).toUpperCase() + type.slice(1);
+  }
+}
+async function recordNotice(input) {
+  const type = input.kind === "budget" ? "budget" : "notice";
+  await deliverEvent(input.mind, {
+    type,
+    body: input.detail,
+    thread: input.thread,
+    delivery: "next-turn",
+    meta: {
+      subtype: input.kind,
+      reason: input.reason,
+      ...input.raw ? { raw: input.raw } : {}
+    }
+  });
+}
+function eventChannel(type, id) {
+  return `event:${type}:${id}`;
+}
+async function recordEventRow(mind, event) {
+  const channel = eventChannel(event.type, event.id);
+  const label = eventLabel(event.type, parseMeta(event.meta, `event ${event.id}`));
+  const metadata = { systemEventId: event.id, label };
+  try {
+    const db = await getDb();
+    const baseName = await getBaseName(mind);
+    await db.insert(mindHistory).values({
+      mind: baseName,
+      type: "event",
+      channel,
+      sender: null,
+      content: event.body,
+      metadata: JSON.stringify(metadata)
+    });
+    publish(baseName, {
+      mind: baseName,
+      type: "event",
+      channel,
+      content: event.body,
+      metadata
+    });
+  } catch (err) {
+    elog.warn(`failed to persist event row for ${mind}`, logger_default.errorData(err));
+  }
+}
+var staleTemplateWarned = /* @__PURE__ */ new Set();
+async function postEventEnvelope(mind, event) {
+  const entry = await findMind(mind);
+  if (!entry) {
+    elog.warn(`cannot deliver event ${event.id} to ${mind}: mind not found`);
+    return false;
+  }
+  const meta = parseMeta(event.meta, `event ${event.id}`);
+  try {
+    const res = await fetch(`http://127.0.0.1:${entry.port}/message`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        kind: "event",
+        event: {
+          id: event.id,
+          type: event.type,
+          label: eventLabel(event.type, meta),
+          body: event.body,
+          at: event.created_at
+        },
+        session: event.thread
+      }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) {
+      elog.warn(`mind ${mind} rejected event ${event.id}: HTTP ${res.status}`);
+      return false;
+    }
+    try {
+      const ack = await res.json();
+      if (ack.event !== true && !staleTemplateWarned.has(mind)) {
+        staleTemplateWarned.add(mind);
+        elog.warn(
+          `mind ${mind} ack'd an event without event support \u2014 its template predates system events; run \`volute mind upgrade ${mind}\``
+        );
+      }
+    } catch {
+      if (!staleTemplateWarned.has(mind)) {
+        staleTemplateWarned.add(mind);
+        elog.warn(
+          `mind ${mind} ack'd an event without event support \u2014 its template predates system events; run \`volute mind upgrade ${mind}\``
+        );
+      }
+    }
+    return true;
+  } catch (err) {
+    elog.warn(`failed to POST event ${event.id} to ${mind}`, logger_default.errorData(err));
+    return false;
+  }
+}
+async function markDelivered(id, extraMeta) {
+  try {
+    const db = await getDb();
+    if (extraMeta) {
+      const row = await db.select({ meta: systemEvents.meta }).from(systemEvents).where(eq(systemEvents.id, id)).get();
+      const merged = { ...parseMeta(row?.meta, `event ${id}`), ...extraMeta };
+      await db.update(systemEvents).set({ delivered_at: sql`(datetime('now'))`, meta: JSON.stringify(merged) }).where(eq(systemEvents.id, id));
+    } else {
+      await db.update(systemEvents).set({ delivered_at: sql`(datetime('now'))` }).where(eq(systemEvents.id, id));
+    }
+  } catch (err) {
+    elog.error(
+      `failed to stamp event ${id} delivered \u2014 it will be redelivered on the next wake/start`,
+      logger_default.errorData(err)
+    );
+  }
+}
+function resolveEventThread(thread, delivery) {
+  if (thread !== "$new") return thread;
+  return delivery === "immediate" ? newEphemeralSession() : MIND_LEVEL_THREAD;
+}
+async function deliverEvent(mind, input) {
+  const delivery = input.delivery ?? "immediate";
+  const thread = resolveEventThread(input.thread ?? "main", delivery);
+  let eventId;
+  try {
+    const db = await getDb();
+    const rows = await db.insert(systemEvents).values({
+      mind,
+      type: input.type,
+      body: input.body,
+      meta: input.meta ? JSON.stringify(input.meta) : null,
+      delivery,
+      thread
+    }).returning({ id: systemEvents.id });
+    eventId = rows[0]?.id;
+    if (eventId == null) {
+      elog.error(`event insert for ${mind} (${input.type}) returned no id \u2014 event dropped`);
+      return { delivered: false };
+    }
+    if (delivery === "next-turn") {
+      await db.run(
+        sql`UPDATE system_events SET delivered_at = datetime('now'), meta = json_set(COALESCE(meta, '{}'), '$.dropped', 1) WHERE mind = ${mind} AND thread = ${thread} AND delivery = 'next-turn' AND delivered_at IS NULL AND id NOT IN (SELECT id FROM system_events WHERE mind = ${mind} AND thread = ${thread} AND delivery = 'next-turn' AND delivered_at IS NULL ORDER BY id DESC LIMIT ${MAX_NEXT_TURN_EVENTS})`
+      );
+      return { id: eventId, delivered: false };
+    }
+    const baseName = await getBaseName(mind);
+    const { getSleepManagerIfReady } = await import("./sleep-manager-7JXEQQ2P.js");
+    const sleepManager = getSleepManagerIfReady();
+    const sleeping = !input.force && sleepManager?.isSleeping(baseName);
+    const behavior = input.whileSleeping ?? "queue";
+    if (sleeping && behavior === "skip") {
+      await markDelivered(eventId, { skipped: true });
+      return { id: eventId, delivered: false };
+    }
+    if (!sleeping) {
+      const event = await db.select().from(systemEvents).where(eq(systemEvents.id, eventId)).get();
+      if (event && await postEventEnvelope(mind, event)) {
+        await markDelivered(eventId);
+        await recordEventRow(mind, event);
+        return { id: eventId, delivered: true };
+      }
+      elog.warn(
+        `event ${eventId} (${input.type}) for ${mind} was not delivered; left pending for the next wake or mind start`
+      );
+      return { id: eventId, delivered: false };
+    }
+    if (behavior === "trigger-wake") {
+      sleepManager?.initiateWake(baseName, { trigger: { channel: `event:${input.type}` } }).catch(
+        (err) => elog.warn(`failed to trigger-wake ${baseName} for event`, logger_default.errorData(err))
+      );
+    }
+    return { id: eventId, delivered: false };
+  } catch (err) {
+    elog.error(`failed to deliver event to ${mind}`, logger_default.errorData(err));
+    return { id: eventId, delivered: false };
+  }
+}
+var NO_REPLAY_TYPES = /* @__PURE__ */ new Set(["sleep"]);
+async function flushQueuedEvents(mind) {
+  try {
+    const db = await getDb();
+    const rows = await db.select().from(systemEvents).where(
+      and(
+        eq(systemEvents.mind, mind),
+        eq(systemEvents.delivery, "immediate"),
+        isNull(systemEvents.delivered_at)
+      )
+    ).orderBy(asc(systemEvents.id)).all();
+    let delivered = 0;
+    for (const event of rows) {
+      if (NO_REPLAY_TYPES.has(event.type) || eventAgeMs(event.created_at) > FLUSH_MAX_AGE_MS) {
+        elog.info(`expiring stale pending event ${event.id} (${event.type}) for ${mind}`);
+        await markDelivered(event.id, { expired: true });
+        continue;
+      }
+      if (await postEventEnvelope(mind, event)) {
+        await markDelivered(event.id);
+        await recordEventRow(mind, event);
+        delivered++;
+      } else {
+        elog.warn(`flush could not deliver event ${event.id} (${event.type}) to ${mind}`);
+      }
+    }
+    return delivered;
+  } catch (err) {
+    elog.warn(`failed to flush queued events for ${mind}`, logger_default.errorData(err));
+    return 0;
+  }
+}
+function eventAgeMs(createdAt) {
+  const iso = createdAt.endsWith("Z") ? createdAt : `${createdAt.replace(" ", "T")}Z`;
+  const t = new Date(iso).getTime();
+  return Number.isNaN(t) ? 0 : Date.now() - t;
+}
+async function pendingEventCount(mind) {
+  try {
+    const db = await getDb();
+    const row = await db.select({ n: sql`count(*)` }).from(systemEvents).where(
+      and(
+        eq(systemEvents.mind, mind),
+        eq(systemEvents.delivery, "immediate"),
+        isNull(systemEvents.delivered_at)
+      )
+    ).get();
+    return row?.n ?? 0;
+  } catch (err) {
+    elog.warn(`failed to count pending events for ${mind}`, logger_default.errorData(err));
+    return 0;
+  }
+}
+function pendingEventsLine(count) {
+  if (count <= 0) return "";
+  return `${count} system event${count === 1 ? "" : "s"} arrived while you slept and will follow shortly.`;
+}
+async function drainEvents(mind, thread, limit = MAX_NEXT_TURN_EVENTS) {
+  const db = await getDb();
+  return db.select().from(systemEvents).where(
+    and(
+      eq(systemEvents.mind, mind),
+      eq(systemEvents.delivery, "next-turn"),
+      isNull(systemEvents.delivered_at),
+      or(eq(systemEvents.thread, thread), eq(systemEvents.thread, MIND_LEVEL_THREAD))
+    )
+  ).orderBy(asc(systemEvents.id)).limit(limit);
+}
+function metaOf(e) {
+  return parseMeta(e.meta, `event ${e.id}`);
+}
+var FAILURE_SUBTYPES = /* @__PURE__ */ new Set(["turn_error", "crash", "startup"]);
+var NOTICE_HEADER = "[Notices] While you were unavailable, one or more turns failed. You're back now:";
+function formatEvents(events) {
+  if (events.length === 0) return null;
+  const failures = [];
+  const budgets = [];
+  const versions = [];
+  const extensions = [];
+  const others = [];
+  for (const e of events) {
+    if (e.type === "budget") budgets.push(e);
+    else if (e.type === "version") versions.push(e);
+    else if (e.type === "notice") {
+      const subtype = String(metaOf(e).subtype);
+      if (FAILURE_SUBTYPES.has(subtype)) failures.push(e);
+      else if (subtype === "extension") extensions.push(e);
+      else others.push(e);
+    } else others.push(e);
+  }
+  const blocks = [];
+  if (failures.length > 0) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const e of failures) {
+      const reason = String(metaOf(e).reason ?? "unknown");
+      const time = localHM(e.created_at);
+      const g = groups.get(reason);
+      if (g) {
+        g.count += 1;
+        g.detail = e.body;
+        g.last = time;
+      } else {
+        groups.set(reason, { count: 1, detail: e.body, first: time, last: time });
+      }
+    }
+    const lines = [...groups.values()].map((g) => {
+      const span = g.first === g.last ? g.first : `${g.first}\u2013${g.last}`;
+      const plural = g.count === 1 ? "turn" : "turns";
+      return `- ${g.count} ${plural} failed (${span}): ${g.detail}`;
+    });
+    blocks.push(`${NOTICE_HEADER}
+${lines.join("\n")}`);
+  }
+  if (budgets.length > 0) {
+    const lines = budgets.map((e) => `- ${localHM(e.created_at)} ${e.body}`);
+    blocks.push(`[Budget]
+${lines.join("\n")}`);
+  }
+  if (versions.length > 0) {
+    const lines = versions.map((e) => `- ${localHM(e.created_at)} ${e.body}`);
+    blocks.push(`[Update]
+${lines.join("\n")}`);
+  }
+  if (extensions.length > 0) {
+    const byExt = /* @__PURE__ */ new Map();
+    for (const e of extensions) {
+      const ext = String(metaOf(e).reason ?? "extension");
+      const arr = byExt.get(ext);
+      if (arr) arr.push(e);
+      else byExt.set(ext, [e]);
+    }
+    for (const [ext, items] of byExt) {
+      const header = `[${ext.charAt(0).toUpperCase()}${ext.slice(1)}]`;
+      const lines = items.map((e) => `- ${localHM(e.created_at)} ${e.body}`);
+      blocks.push(`${header}
+${lines.join("\n")}`);
+    }
+  }
+  if (others.length > 0) {
+    const lines = others.map(
+      (e) => `- ${localHM(e.created_at)} (${eventLabel(e.type, metaOf(e))}) ${e.body}`
+    );
+    blocks.push(`[Events]
+${lines.join("\n")}`);
+  }
+  return blocks.join("\n\n");
+}
+function localHM(createdAt) {
+  const iso = createdAt.endsWith("Z") ? createdAt : `${createdAt.replace(" ", "T")}Z`;
+  return new Date(iso).toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit" });
+}
+async function clearDeliveredEvents(mind, thread, uptoId) {
+  try {
+    const db = await getDb();
+    await db.update(systemEvents).set({ delivered_at: sql`(datetime('now'))` }).where(
+      and(
+        eq(systemEvents.mind, mind),
+        eq(systemEvents.delivery, "next-turn"),
+        isNull(systemEvents.delivered_at),
+        or(eq(systemEvents.thread, thread), eq(systemEvents.thread, MIND_LEVEL_THREAD)),
+        lte(systemEvents.id, uptoId)
+      )
+    );
+  } catch (err) {
+    elog.warn(`failed to clear delivered events for ${mind}:${thread}`, logger_default.errorData(err));
+  }
+}
+var failureReadErrorLogged = false;
+async function latestFailureEvent(mind) {
+  try {
+    const db = await getDb();
+    const e = await db.select().from(systemEvents).where(
+      and(
+        eq(systemEvents.mind, mind),
+        eq(systemEvents.type, "notice"),
+        isNull(systemEvents.delivered_at),
+        // Closed set of literal subtypes (not user input).
+        sql`json_extract(${systemEvents.meta}, '$.subtype') IN ('turn_error', 'crash', 'startup')`
+      )
+    ).orderBy(desc(systemEvents.id)).limit(1).get();
+    if (!e) return null;
+    const recovered = await db.select({ id: turns.id }).from(turns).where(
+      and(eq(turns.mind, mind), eq(turns.status, "complete"), gt(turns.created_at, e.created_at))
+    ).limit(1);
+    if (recovered.length > 0) return null;
+    const m = metaOf(e);
+    return {
+      kind: String(m.subtype ?? "notice"),
+      reason: String(m.reason ?? "unknown"),
+      detail: e.body,
+      at: e.created_at
+    };
+  } catch (err) {
+    if (!failureReadErrorLogged) {
+      failureReadErrorLogged = true;
+      elog.error(`failed to read latest failure event for ${mind}`, logger_default.errorData(err));
+    }
+    return null;
+  }
+}
+async function latestEvent(mind) {
+  const db = await getDb();
+  const row = await db.select().from(systemEvents).where(
+    and(
+      eq(systemEvents.mind, mind),
+      eq(systemEvents.delivery, "next-turn"),
+      isNull(systemEvents.delivered_at)
+    )
+  ).orderBy(desc(systemEvents.id)).limit(1).get();
+  if (!row) return null;
+  const m = metaOf(row);
+  return {
+    kind: String(m.subtype ?? row.type),
+    reason: String(m.reason ?? row.type),
+    detail: row.body,
+    created_at: row.created_at
+  };
+}
+async function hasUndeliveredEvent(mind, reason) {
+  const db = await getDb();
+  const row = await db.select({ id: systemEvents.id }).from(systemEvents).where(
+    and(
+      eq(systemEvents.mind, mind),
+      eq(systemEvents.delivery, "next-turn"),
+      isNull(systemEvents.delivered_at),
+      sql`json_extract(${systemEvents.meta}, '$.reason') = ${reason}`
+    )
+  ).limit(1).get();
+  return row != null;
+}
+async function listEvents(mind, limit = 100, before) {
+  const db = await getDb();
+  const conditions = [eq(systemEvents.mind, mind)];
+  if (before != null) conditions.push(sql`${systemEvents.id} < ${before}`);
+  return db.select().from(systemEvents).where(and(...conditions)).orderBy(desc(systemEvents.id)).limit(limit);
+}
+async function recordReflection(mind, eventId, text) {
+  try {
+    const db = await getDb();
+    await db.update(systemEvents).set({ reflection: text }).where(and(eq(systemEvents.id, eventId), eq(systemEvents.mind, mind)));
+  } catch (err) {
+    elog.warn(`failed to record reflection for event ${eventId}`, logger_default.errorData(err));
+  }
+}
+async function captureReflection(mind, turnId) {
+  if (!turnId) return;
+  try {
+    const db = await getDb();
+    const turn = await db.select({ trigger: turns.trigger_event_id }).from(turns).where(eq(turns.id, turnId)).get();
+    if (turn?.trigger == null) return;
+    const trigger = await db.select({ metadata: mindHistory.metadata }).from(mindHistory).where(eq(mindHistory.id, turn.trigger)).get();
+    const eventId = trigger?.metadata ? parseMeta(trigger.metadata, `event row ${turn.trigger}`).systemEventId : void 0;
+    if (typeof eventId !== "number") return;
+    const row = await db.select({ content: mindHistory.content }).from(mindHistory).where(
+      and(
+        eq(mindHistory.mind, mind),
+        eq(mindHistory.turn_id, turnId),
+        eq(mindHistory.type, "text")
+      )
+    ).orderBy(desc(mindHistory.id)).limit(1).get();
+    const text = row?.content?.trim();
+    if (text) await recordReflection(mind, eventId, text);
+  } catch (err) {
+    elog.warn(`failed to capture reflection for turn ${turnId}`, logger_default.errorData(err));
+  }
+}
+
+export {
+  newEphemeralSession,
+  MIND_LEVEL_THREAD,
+  parseMeta,
+  eventLabel,
+  recordNotice,
+  eventChannel,
+  deliverEvent,
+  flushQueuedEvents,
+  pendingEventCount,
+  pendingEventsLine,
+  drainEvents,
+  formatEvents,
+  clearDeliveredEvents,
+  latestFailureEvent,
+  latestEvent,
+  hasUndeliveredEvent,
+  listEvents,
+  recordReflection,
+  captureReflection
+};

package/dist/{chunk-FBBS4BVR.js → chunk-ICXY54ZC.js}

@@ -12,7 +12,7 @@ import {
   mindDir,
   readAllMinds,
   voluteHome
-} from "./chunk-RSBL3FAD.js";
+} from "./chunk-H6X6CKDN.js";
 
 // packages/daemon/src/lib/util/avatar-image.ts
 import { readdir, readFile, writeFile } from "fs/promises";

package/dist/{chunk-DAIIMBLB.js → chunk-IWAVIJO2.js}

@@ -8,14 +8,12 @@ import {
   modeLabel,
   pollHealth,
   startService
-} from "./chunk-HCYQRME2.js";
-import {
-  readGlobalConfig
-} from "./chunk-NJHN6IRB.js";
+} from "./chunk-6NLW72HP.js";
 import {
+  readGlobalConfig,
   voluteHome,
   voluteSystemDir
-} from "./chunk-RSBL3FAD.js";
+} from "./chunk-H6X6CKDN.js";
 
 // src/commands/up.ts
 import { spawn } from "child_process";

package/dist/{chunk-TXJL36ZQ.js → chunk-JHKBALS2.js}

@@ -2,7 +2,7 @@
 import {
   MEMORY_PLACEHOLDER_MARKER,
   ORIENTATION_MARKER
-} from "./chunk-JPGHSXSV.js";
+} from "./chunk-FXWBFDQR.js";
 import {
   safeResolveWithinBase
 } from "./chunk-DW4TRDOZ.js";
@@ -11,7 +11,7 @@ import {
 } from "./chunk-WCFSBH33.js";
 import {
   isImagegenEnabled
-} from "./chunk-NJHN6IRB.js";
+} from "./chunk-H6X6CKDN.js";
 
 // packages/daemon/src/lib/mind/seed-readiness.ts
 import { existsSync, readFileSync } from "fs";

package/dist/{chunk-MG3Z34YE.js → chunk-L7BKTZ5U.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-QUSMYGNQ.js";
 import {
   voluteSystemDir
-} from "./chunk-RSBL3FAD.js";
+} from "./chunk-H6X6CKDN.js";
 
 // packages/daemon/src/lib/bridges/bridges.ts
 import { existsSync, readFileSync, writeFileSync } from "fs";

package/dist/{chunk-SX72DOO3.js → chunk-LAUCO2HC.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   voluteSystemDir
-} from "./chunk-RSBL3FAD.js";
+} from "./chunk-H6X6CKDN.js";
 
 // packages/daemon/src/lib/update-check.ts
 import { execFile as execFileCb, execFileSync } from "child_process";

package/dist/chunk-LNNI3MS4.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import {
+  logger_default
+} from "./chunk-QUSMYGNQ.js";
+
+// packages/daemon/src/lib/events/mind-events.ts
+var subscribers = /* @__PURE__ */ new Map();
+var globalSubscribers = /* @__PURE__ */ new Set();
+function subscribe(mind, callback) {
+  let set = subscribers.get(mind);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    subscribers.set(mind, set);
+  }
+  set.add(callback);
+  return () => {
+    set.delete(callback);
+    if (set.size === 0) subscribers.delete(mind);
+  };
+}
+function subscribeAll(callback) {
+  globalSubscribers.add(callback);
+  return () => {
+    globalSubscribers.delete(callback);
+  };
+}
+function publish(mind, event) {
+  const set = subscribers.get(mind);
+  if (set) {
+    for (const cb of set) {
+      try {
+        cb(event);
+      } catch (err) {
+        logger_default.error(`[mind-events] subscriber threw for ${mind}`, logger_default.errorData(err));
+        set.delete(cb);
+        if (set.size === 0) subscribers.delete(mind);
+      }
+    }
+  }
+  for (const cb of globalSubscribers) {
+    try {
+      cb(event);
+    } catch (err) {
+      logger_default.error("[mind-events] global subscriber threw", logger_default.errorData(err));
+      globalSubscribers.delete(cb);
+    }
+  }
+}
+
+export {
+  subscribe,
+  subscribeAll,
+  publish
+};