volute 0.49.0 → 0.51.0

package/dist/chunk-7HN63Q7J.js

@@ -0,0 +1,1317 @@
+#!/usr/bin/env node
+import {
+  tryGetMindManager
+} from "./chunk-VAEZCIJC.js";
+import {
+  extractTextContent,
+  getRoutingConfig,
+  resolveDeliveryMode,
+  resolveRoute,
+  setRoutesChangeListener,
+  shouldGate
+} from "./chunk-UDZLPR34.js";
+import {
+  linkInboundToActiveTurn
+} from "./chunk-CDKQJWGK.js";
+import {
+  MIND_LEVEL_THREAD,
+  newEphemeralSession
+} from "./chunk-ICL6T4SN.js";
+import {
+  publish
+} from "./chunk-LNNI3MS4.js";
+import {
+  getParticipants,
+  publish as publish2
+} from "./chunk-TPX6E6PL.js";
+import {
+  onMindEvent
+} from "./chunk-UFTDRTCP.js";
+import {
+  renderAvatarBlock
+} from "./chunk-ICXY54ZC.js";
+import {
+  readVoluteConfig
+} from "./chunk-WCFSBH33.js";
+import {
+  logger_default
+} from "./chunk-QUSMYGNQ.js";
+import {
+  findMind,
+  getBaseName,
+  getDb,
+  mindDir,
+  voluteHome
+} from "./chunk-H6X6CKDN.js";
+import {
+  channelGates,
+  deliveryQueue,
+  messages,
+  mindHistory
+} from "./chunk-2RNMBXD2.js";
+
+// packages/daemon/src/lib/delivery/delivery-manager.ts
+import { realpath } from "fs/promises";
+import { resolve } from "path";
+import { and as and2, eq as eq2, inArray, sql } from "drizzle-orm";
+
+// packages/daemon/src/lib/chat/typing.ts
+var DEFAULT_TTL_MS = 1e4;
+var SWEEP_INTERVAL_MS = 5e3;
+var TypingMap = class {
+  channels = /* @__PURE__ */ new Map();
+  sweepTimer;
+  constructor() {
+    this.sweepTimer = setInterval(() => this.sweep(), SWEEP_INTERVAL_MS);
+    this.sweepTimer.unref();
+  }
+  set(channel, sender, opts) {
+    const expiresAt = opts?.persistent ? Infinity : Date.now() + (opts?.ttlMs ?? DEFAULT_TTL_MS);
+    let senders = this.channels.get(channel);
+    if (!senders) {
+      senders = /* @__PURE__ */ new Map();
+      this.channels.set(channel, senders);
+    }
+    senders.set(sender, { expiresAt });
+  }
+  delete(channel, sender) {
+    const senders = this.channels.get(channel);
+    if (senders) {
+      senders.delete(sender);
+      if (senders.size === 0) {
+        this.channels.delete(channel);
+      }
+    }
+  }
+  /** Remove a sender from all channels (e.g. when a mind finishes processing). Returns affected channel names. */
+  deleteSender(sender) {
+    const affected = [];
+    for (const [channel, senders] of this.channels) {
+      if (senders.has(sender)) {
+        senders.delete(sender);
+        affected.push(channel);
+      }
+      if (senders.size === 0) {
+        this.channels.delete(channel);
+      }
+    }
+    return affected;
+  }
+  get(channel) {
+    const senders = this.channels.get(channel);
+    if (!senders) return [];
+    const now = Date.now();
+    const result = [];
+    for (const [sender, entry] of senders) {
+      if (entry.expiresAt > now) {
+        result.push(sender);
+      }
+    }
+    return result;
+  }
+  dispose() {
+    clearInterval(this.sweepTimer);
+    this.channels.clear();
+    if (instance === this) instance = void 0;
+  }
+  sweep() {
+    const now = Date.now();
+    for (const [channel, senders] of this.channels) {
+      for (const [sender, entry] of senders) {
+        if (entry.expiresAt <= now) {
+          senders.delete(sender);
+        }
+      }
+      if (senders.size === 0) {
+        this.channels.delete(channel);
+      }
+    }
+  }
+};
+var instance;
+function getTypingMap() {
+  if (!instance) {
+    instance = new TypingMap();
+  }
+  return instance;
+}
+function isConversationId(channel) {
+  return !channel.startsWith("@") && !channel.startsWith("#") && !channel.includes(":") && !channel.includes("/");
+}
+function publishTypingForChannels(channels, map) {
+  for (const channel of channels) {
+    if (isConversationId(channel)) {
+      publish2(channel, { type: "typing", senders: map.get(channel) });
+    }
+  }
+}
+
+// packages/daemon/src/lib/delivery/send-gate.ts
+import { and, asc, desc, eq, gt } from "drizzle-orm";
+var state = /* @__PURE__ */ new Map();
+function extractText(raw) {
+  if (!raw) return "";
+  try {
+    const blocks = JSON.parse(raw);
+    if (Array.isArray(blocks)) {
+      return blocks.filter((b) => b?.type === "text" && typeof b.text === "string").map((b) => b.text).join(" ").trim();
+    }
+  } catch {
+  }
+  return String(raw);
+}
+async function maxMessageId(conversationId) {
+  const db = await getDb();
+  const rows = await db.select({ id: messages.id }).from(messages).where(eq(messages.conversation_id, conversationId)).orderBy(desc(messages.id)).limit(1);
+  return rows[0]?.id ?? 0;
+}
+async function onDeliveredToMind(mindBase, conversationId) {
+  if (!conversationId) return;
+  let conv = state.get(mindBase);
+  if (!conv) {
+    conv = /* @__PURE__ */ new Map();
+    state.set(mindBase, conv);
+  }
+  const existing = conv.get(conversationId);
+  if (existing?.turnOpen) return;
+  const baselineId = await maxMessageId(conversationId);
+  conv.set(conversationId, { baselineId, heldThisTurn: false, turnOpen: true });
+}
+async function checkStaleSend(mindBase, conversationId, excludeSenders) {
+  const entry = state.get(mindBase)?.get(conversationId);
+  if (!entry?.turnOpen || entry.heldThisTurn) return { held: false };
+  const db = await getDb();
+  const rows = await db.select({ id: messages.id, sender: messages.sender_name, content: messages.content }).from(messages).where(and(eq(messages.conversation_id, conversationId), gt(messages.id, entry.baselineId))).orderBy(asc(messages.id));
+  const excluded = new Set(excludeSenders.filter(Boolean));
+  const unseen = rows.filter((r) => r.sender && !excluded.has(r.sender));
+  if (unseen.length === 0) return { held: false };
+  entry.heldThisTurn = true;
+  entry.baselineId = rows[rows.length - 1].id;
+  return {
+    held: true,
+    unseen: unseen.map((r) => ({ sender: r.sender, text: extractText(r.content) }))
+  };
+}
+function clearMind(mindBase) {
+  state.delete(mindBase);
+}
+function resetTurn(mindBase) {
+  clearMind(mindBase);
+}
+function formatHoldNotice(channelLabel, unseen) {
+  const lines = unseen.map((m) => {
+    const t = m.text.length > 120 ? `${m.text.slice(0, 119)}\u2026` : m.text;
+    return `  ${m.sender}: ${JSON.stringify(t)}`;
+  });
+  const n = unseen.length;
+  return [
+    `\u26A0 Not sent \u2014 ${n} newer message${n === 1 ? "" : "s"} arrived on ${channelLabel} while you were composing:`,
+    ...lines,
+    "Your message was NOT posted. Revise it in light of these, or run the same send again to post as-is."
+  ].join("\n");
+}
+
+// packages/daemon/src/lib/delivery/delivery-manager.ts
+var dlog = logger_default.child("delivery-manager");
+var MAX_BATCH_SIZE = 50;
+var REDRIVE_INTERVAL_MS = 15e3;
+var RETRY_BASE_MS = 5e3;
+var RETRY_MAX_MS = 5 * 6e4;
+var REDRIVE_BATCH_LIMIT = 200;
+var MAX_DELIVERY_ATTEMPTS = 10;
+var GATED_RELEASE_LIMIT_PER_CHANNEL = 10;
+var GATED_NOTIFY_EVERY = 10;
+var mentionRegexCache = /* @__PURE__ */ new Map();
+var avatarBlocksCache = /* @__PURE__ */ new Map();
+var AVATAR_CACHE_TTL = 5 * 60 * 1e3;
+var DeliveryManager = class {
+  sessionStates = /* @__PURE__ */ new Map();
+  batchBuffers = /* @__PURE__ */ new Map();
+  /**
+   * delivery_queue row ids currently owned in-memory — either buffered in a batch
+   * buffer or actively being POSTed. The redrive sweep skips these so it never
+   * double-delivers a row that the normal path is already handling.
+   */
+  inFlight = /* @__PURE__ */ new Set();
+  /**
+   * Per-`(baseName:session)` promise chain that serializes POSTs so two rapid
+   * messages to the same session can't be reordered by resolvePort/enrichment latency.
+   */
+  drainChains = /* @__PURE__ */ new Map();
+  redriveTimer = null;
+  /** Predicate for whether a mind is up; overridable in tests. */
+  isMindRunning = (name) => tryGetMindManager()?.isRunning(name) ?? false;
+  /** Delivers a channel event to a mind (invites, release summaries); overridable in tests. */
+  notify = async (mindName, text) => {
+    const { deliverEvent } = await import("./system-events-ZPSH63QX.js");
+    await deliverEvent(mindName, { type: "channel", body: text });
+  };
+  /** Surfaces a dead-lettered delivery as a next-turn failure notice; overridable in tests. */
+  notifyFailure = async (input) => {
+    const { recordNotice } = await import("./system-events-ZPSH63QX.js");
+    await recordNotice(input);
+  };
+  constructor() {
+    setRoutesChangeListener((mind) => {
+      this.releaseGated(mind).catch(
+        (err) => dlog.warn(`failed to release gated messages for ${mind}`, logger_default.errorData(err))
+      );
+    });
+  }
+  /** Test seam: override the mind-running predicate. */
+  setRunningCheck(fn) {
+    this.isMindRunning = fn;
+  }
+  /** Test seam: capture/override system notifications sent to minds. */
+  setNotifier(fn) {
+    this.notify = fn;
+  }
+  /** Test seam: capture/override dead-letter failure notices. */
+  setFailureNotifier(fn) {
+    this.notifyFailure = fn;
+  }
+  // --- Public API ---
+  /**
+   * Route and deliver a message to a mind. This is the main entry point.
+   * The message is routed via the mind's routes.json, then either delivered immediately
+   * or queued for batching depending on the session's delivery mode.
+   */
+  async routeAndDeliver(mindName, payload) {
+    const baseName = await getBaseName(mindName);
+    const config = getRoutingConfig(baseName);
+    if (payload.session) {
+      let sessionName2 = payload.session;
+      if (sessionName2 === "$new") {
+        sessionName2 = newEphemeralSession();
+      }
+      const sessionConfig2 = resolveDeliveryMode(config, sessionName2);
+      if (sessionConfig2.delivery.mode === "batch") {
+        await this.enqueueBatch(mindName, sessionName2, payload, sessionConfig2);
+        return { routed: true, session: sessionName2, destination: "mind", mode: "batch" };
+      }
+      const queueId2 = await this.persistToQueue(mindName, sessionName2, payload);
+      await this.deliverToMind(mindName, sessionName2, payload, sessionConfig2, queueId2);
+      return { routed: true, session: sessionName2, destination: "mind", mode: "immediate" };
+    }
+    const meta = {
+      channel: payload.channel,
+      sender: payload.sender ?? void 0,
+      isDM: payload.isDM,
+      participantCount: payload.participantCount
+    };
+    const route = resolveRoute(config, meta);
+    dlog.debug(
+      `route for ${mindName} ch=${payload.channel}: dest=${route.destination} matched=${route.matched}`
+    );
+    if (route.destination === "file") {
+      return { routed: true, session: route.path, destination: "file", mode: "immediate" };
+    }
+    if (shouldGate(config, route)) {
+      dlog.debug(`gating unmatched channel ${payload.channel} for ${mindName}`);
+      await this.gateMessage(mindName, route.session, payload);
+      return { routed: true, session: route.session, destination: "mind", mode: "gated" };
+    }
+    if (route.mode === "mention" && payload.sender) {
+      const text = extractTextContent(payload.content);
+      let pattern = mentionRegexCache.get(baseName);
+      if (!pattern) {
+        const escaped = baseName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        pattern = new RegExp(`\\b${escaped}\\b`, "i");
+        mentionRegexCache.set(baseName, pattern);
+      }
+      if (!pattern.test(text)) {
+        dlog.debug(`mention-filtered message on ${payload.channel} for ${mindName}`);
+        return { routed: false, reason: "mention-filtered" };
+      }
+    }
+    let sessionName = route.session;
+    if (sessionName === "$new") {
+      sessionName = newEphemeralSession();
+    }
+    const sessionConfig = resolveDeliveryMode(config, sessionName, route.rule);
+    if (sessionConfig.delivery.mode === "batch") {
+      dlog.debug(`enqueueing batch message for ${mindName}/${sessionName}`);
+      await this.enqueueBatch(mindName, sessionName, payload, sessionConfig);
+      return { routed: true, session: sessionName, destination: "mind", mode: "batch" };
+    }
+    const queueId = await this.persistToQueue(mindName, sessionName, payload);
+    await this.deliverToMind(mindName, sessionName, payload, sessionConfig, queueId);
+    return { routed: true, session: sessionName, destination: "mind", mode: "immediate" };
+  }
+  /**
+   * Called when a mind's session emits a "done" event — decrements active count
+   * and may trigger batch flush if session goes idle.
+   *
+   * This method is intentionally synchronous to avoid race conditions: the caller
+   * has already resolved baseName, and any async yield here (e.g. getBaseName)
+   * would allow concurrent deliveries to incrementActive before the decrement runs,
+   * causing isSessionBusy to return true even when no deliveries are pending.
+   */
+  sessionDone(baseName, session) {
+    resetTurn(baseName);
+    if (session) {
+      this.decrementActive(baseName, session);
+    } else {
+      const mindSessions = this.sessionStates.get(baseName);
+      if (mindSessions) {
+        for (const [sessionName] of mindSessions) {
+          this.decrementActive(baseName, sessionName);
+        }
+      }
+    }
+  }
+  /**
+   * Restore queued messages from DB on daemon restart — a single redrive pass.
+   * All accepted deliveries are persisted to delivery_queue before their POST and
+   * only deleted on mind-ack, so pending rows are exactly the undelivered messages.
+   */
+  async restoreFromDb() {
+    await this.redrive();
+  }
+  /** Start the periodic redrive sweep (idempotent). */
+  startRedrive() {
+    if (this.redriveTimer) return;
+    this.redriveTimer = setInterval(() => {
+      this.redrive().catch((err) => dlog.warn("redrive sweep failed", logger_default.errorData(err)));
+    }, REDRIVE_INTERVAL_MS);
+    this.redriveTimer.unref();
+  }
+  /**
+   * Re-read pending delivery_queue rows that are eligible (past their backoff window)
+   * and re-deliver them through the normal path. Rows already owned in-memory
+   * (`inFlight`) and minds that are down are skipped so we never hot-loop or double-send.
+   */
+  async redrive() {
+    let rows;
+    try {
+      const db = await getDb();
+      rows = await db.select().from(deliveryQueue).where(
+        and2(
+          eq2(deliveryQueue.status, "pending"),
+          sql`(${deliveryQueue.next_attempt_at} IS NULL OR ${deliveryQueue.next_attempt_at} <= datetime('now'))`
+        )
+      ).orderBy(deliveryQueue.id).limit(REDRIVE_BATCH_LIMIT);
+    } catch (err) {
+      dlog.warn("failed to read delivery queue for redrive", logger_default.errorData(err));
+      return;
+    }
+    let redriven = 0;
+    for (const row of rows) {
+      if (this.inFlight.has(row.id)) continue;
+      if (!this.isMindRunning(row.mind)) continue;
+      let payload;
+      try {
+        payload = JSON.parse(row.payload);
+      } catch (parseErr) {
+        dlog.warn(
+          `corrupt payload in delivery queue row ${row.id}, dropping`,
+          logger_default.errorData(parseErr)
+        );
+        await this.deleteQueueRows([row.id]);
+        continue;
+      }
+      const config = getRoutingConfig(row.mind);
+      const sessionConfig = resolveDeliveryMode(config, row.thread);
+      const target = row.target_mind ?? row.mind;
+      if (sessionConfig.delivery.mode === "batch") {
+        this.inFlight.add(row.id);
+        this.addToBatchBuffer(target, row.thread, sessionConfig, {
+          payload,
+          channel: payload.channel,
+          sender: payload.sender ?? null,
+          createdAt: Date.now(),
+          queueId: row.id
+        });
+      } else {
+        this.deliverToMind(target, row.thread, payload, sessionConfig, row.id).catch((err) => {
+          dlog.warn(`failed to redrive delivery for ${target}`, logger_default.errorData(err));
+        });
+      }
+      redriven++;
+    }
+    if (redriven > 0) dlog.info(`redrove ${redriven} pending delivery queue rows`);
+  }
+  /**
+   * Re-evaluate a mind's `gated` rows against its current routes.json when the routing
+   * config changes. For each channel that now matches a `mind` route:
+   *  - the newest {@link GATED_RELEASE_LIMIT_PER_CHANNEL} rows are promoted to `pending`
+   *    and re-stamped with the freshly-resolved session (NOT the gate-time fallback), so
+   *    they land in the correct session instead of `main` (#537 bug 1);
+   *  - any older rows are `archived` (inert) so a long backlog can't flood the mind
+   *    in one sweep (#537 bug 2), and the mind gets one summary rather than a flood.
+   * Rows resolving to a `file` destination are archived (the delivery manager doesn't
+   * deliver file routes). Declined channels are skipped entirely — they stay gated.
+   */
+  async releaseGated(mindName) {
+    const baseName = await getBaseName(mindName);
+    const config = getRoutingConfig(baseName);
+    let rows;
+    try {
+      const db = await getDb();
+      rows = await db.select().from(deliveryQueue).where(and2(eq2(deliveryQueue.mind, baseName), eq2(deliveryQueue.status, "gated")));
+    } catch (err) {
+      dlog.warn(`failed to read gated rows for ${baseName}`, logger_default.errorData(err));
+      return;
+    }
+    const byChannel = /* @__PURE__ */ new Map();
+    const archiveIds = [];
+    for (const row of rows) {
+      let payload;
+      try {
+        payload = JSON.parse(row.payload);
+      } catch {
+        continue;
+      }
+      const meta = {
+        channel: payload.channel,
+        sender: payload.sender ?? void 0,
+        isDM: payload.isDM,
+        participantCount: payload.participantCount
+      };
+      const route = resolveRoute(config, meta);
+      if (!route.matched) continue;
+      if (route.destination === "file") {
+        archiveIds.push(row.id);
+        continue;
+      }
+      let session = route.session;
+      if (session === "$new") {
+        session = newEphemeralSession();
+      }
+      const channel = row.channel ?? payload.channel ?? "unknown";
+      const list = byChannel.get(channel) ?? [];
+      list.push({
+        id: row.id,
+        session,
+        channel,
+        sender: payload.sender ?? row.sender ?? null,
+        content: extractTextContent(payload.content)
+      });
+      byChannel.set(channel, list);
+    }
+    const promote = [];
+    const truncationNotes = [];
+    for (const [channel, items] of byChannel) {
+      if (await this.isChannelDeclined(baseName, channel)) continue;
+      items.sort((a, b) => b.id - a.id);
+      const keep = items.slice(0, GATED_RELEASE_LIMIT_PER_CHANNEL);
+      const drop = items.slice(GATED_RELEASE_LIMIT_PER_CHANNEL);
+      promote.push(...keep);
+      for (const d of drop) archiveIds.push(d.id);
+      if (drop.length > 0) {
+        truncationNotes.push(
+          `${channel}: released the ${keep.length} most recent message(s); ${drop.length} earlier message(s) were held while unrouted and remain in the channel history (volute chat read ${channel}).`
+        );
+        dlog.info(
+          `truncated gated release for ${baseName} on ${channel}: kept ${keep.length}, archived ${drop.length}`
+        );
+      }
+    }
+    if (archiveIds.length > 0) {
+      try {
+        const db = await getDb();
+        for (let i = 0; i < archiveIds.length; i += 500) {
+          await db.update(deliveryQueue).set({ status: "archived" }).where(inArray(deliveryQueue.id, archiveIds.slice(i, i + 500)));
+        }
+      } catch (err) {
+        dlog.warn(`failed to archive gated rows for ${baseName}`, logger_default.errorData(err));
+      }
+    }
+    if (promote.length === 0) {
+      if (truncationNotes.length > 0) await this.sendReleaseSummary(mindName, truncationNotes);
+      return;
+    }
+    const orderedPromote = [...promote].sort((a, b) => a.id - b.id);
+    try {
+      const db = await getDb();
+      for (const p of orderedPromote) {
+        await db.transaction(async (tx) => {
+          await tx.insert(mindHistory).values({
+            mind: baseName,
+            type: "inbound",
+            channel: p.channel,
+            sender: p.sender,
+            content: p.content
+          });
+          await tx.update(deliveryQueue).set({ status: "pending", thread: p.session, attempts: 0, next_attempt_at: null }).where(eq2(deliveryQueue.id, p.id));
+        });
+      }
+      dlog.info(`released ${promote.length} gated message(s) for ${baseName} after route change`);
+    } catch (err) {
+      dlog.error(
+        `failed to record+promote gated rows for ${baseName} (channels: ${[...byChannel.keys()].join(", ")})`,
+        logger_default.errorData(err)
+      );
+      return;
+    }
+    for (const p of orderedPromote) {
+      publish(baseName, {
+        mind: baseName,
+        type: "inbound",
+        channel: p.channel,
+        content: p.content ?? void 0,
+        sender: p.sender ?? void 0
+      });
+    }
+    if (truncationNotes.length > 0) await this.sendReleaseSummary(mindName, truncationNotes);
+    await this.redrive();
+  }
+  /**
+   * Whether the mind has explicitly declined a channel. A declined channel keeps
+   * persisting history but never notifies and is never released. #537
+   */
+  async isChannelDeclined(baseName, channel) {
+    if (!channel) return false;
+    try {
+      const db = await getDb();
+      const rows = await db.select({ state: channelGates.state }).from(channelGates).where(and2(eq2(channelGates.mind, baseName), eq2(channelGates.channel, channel)));
+      return rows[0]?.state === "declined";
+    } catch (err) {
+      dlog.warn(`failed to read gate state for ${baseName}/${channel}`, logger_default.errorData(err));
+      return false;
+    }
+  }
+  /**
+   * Record that a mind has declined an unrouted channel: future messages are still
+   * persisted (history is preserved) but never notify, and any currently-gated rows are
+   * archived so they're inert. Returns the number of held messages archived. #537
+   */
+  async declineChannel(mindName, channel) {
+    const baseName = await getBaseName(mindName);
+    const db = await getDb();
+    await db.insert(channelGates).values({ mind: baseName, channel, state: "declined" }).onConflictDoUpdate({
+      target: [channelGates.mind, channelGates.channel],
+      set: { state: "declined", updated_at: sql`(datetime('now'))` }
+    });
+    const archived = await db.update(deliveryQueue).set({ status: "archived" }).where(
+      and2(
+        eq2(deliveryQueue.mind, baseName),
+        eq2(deliveryQueue.channel, channel),
+        eq2(deliveryQueue.status, "gated")
+      )
+    ).returning({ id: deliveryQueue.id });
+    dlog.info(
+      `declined channel ${channel} for ${baseName}; archived ${archived.length} held row(s)`
+    );
+    return archived.length;
+  }
+  /**
+   * Send the mind a single summary when a routing change released a truncated backlog,
+   * rather than a flood of individual messages. #537
+   */
+  async sendReleaseSummary(mindName, notes) {
+    const body = [
+      `[Channel backlog released]`,
+      `A routing change matched channel(s) that had held messages while unrouted. To avoid flooding you, only the ${GATED_RELEASE_LIMIT_PER_CHANNEL} most recent per channel were delivered:`,
+      "",
+      ...notes.map((n) => `- ${n}`)
+    ].join("\n");
+    try {
+      await this.notify(mindName, body);
+    } catch (err) {
+      dlog.warn(`failed to send release summary for ${mindName}`, logger_default.errorData(err));
+    }
+  }
+  /**
+   * Get pending (gated) messages for a mind.
+   */
+  async getPending(mindName) {
+    const db = await getDb();
+    const rows = await db.select().from(deliveryQueue).where(and2(eq2(deliveryQueue.mind, mindName), eq2(deliveryQueue.status, "gated")));
+    const byChannel = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const ch = row.channel ?? "unknown";
+      const existing = byChannel.get(ch) ?? [];
+      existing.push(row);
+      byChannel.set(ch, existing);
+    }
+    return [...byChannel.entries()].map(([channel, channelRows]) => {
+      const firstRow = channelRows[0];
+      const payload = JSON.parse(firstRow.payload);
+      const text = extractTextContent(payload.content);
+      return {
+        channel,
+        sender: firstRow.sender,
+        count: channelRows.length,
+        firstSeen: firstRow.created_at,
+        preview: text.length > 200 ? `${text.slice(0, 200)}...` : text
+      };
+    });
+  }
+  /**
+   * Check if a session is currently busy (has active deliveries).
+   */
+  isSessionBusy(mindName, session) {
+    const state2 = this.sessionStates.get(mindName)?.get(session);
+    return (state2?.activeCount ?? 0) > 0;
+  }
+  /**
+   * Check if any session for a mind is currently busy.
+   */
+  isMindBusy(mindName) {
+    const mindSessions = this.sessionStates.get(mindName);
+    if (!mindSessions) return false;
+    for (const [, state2] of mindSessions) {
+      if (state2.activeCount > 0) return true;
+    }
+    return false;
+  }
+  /**
+   * Clear all session state for a specific mind (called on mind stop/crash).
+   * Resets active counts, clears typing indicators, and cleans up batch buffers
+   * so ghost state doesn't accumulate.
+   */
+  clearMindSessions(mindName) {
+    this.sessionStates.delete(mindName);
+    clearMind(mindName);
+    const typingMap = getTypingMap();
+    publishTypingForChannels(typingMap.deleteSender(mindName), typingMap);
+    const toDelete = [];
+    for (const [bufferKey, buffer] of this.batchBuffers) {
+      if (bufferKey.startsWith(`${mindName}:`)) {
+        if (buffer.debounceTimer) clearTimeout(buffer.debounceTimer);
+        if (buffer.maxWaitTimer) clearTimeout(buffer.maxWaitTimer);
+        for (const msg of buffer.messages) {
+          if (msg.queueId != null) this.inFlight.delete(msg.queueId);
+        }
+        toDelete.push(bufferKey);
+      }
+    }
+    for (const k of toDelete) this.batchBuffers.delete(k);
+  }
+  /**
+   * Reset a single session's leaked active count back to zero.
+   *
+   * Used by the wedged-turn sweep: when a session's `activeCount` drifts above zero
+   * (deliveries outnumbering `done`s) it gates turn completion indefinitely. Once the sweep
+   * confirms the session is genuinely idle, this clears the stale count so the next turn
+   * can complete normally. Batch buffers are left intact — their own maxWait timer flushes
+   * any pending messages.
+   *
+   * `minIdleMs` guards against a race: if a delivery landed within that window, a fresh turn
+   * may legitimately be in flight (real `activeCount`), so zeroing would complete it early.
+   * In that case we skip — the next sweep retries if it's still wedged. Returns whether the
+   * count was reset.
+   */
+  clearSessionActive(mindName, session, minIdleMs) {
+    const state2 = this.sessionStates.get(mindName)?.get(session);
+    if (!state2) return false;
+    if (Date.now() - state2.lastDeliveredAt < minIdleMs) return false;
+    state2.activeCount = 0;
+    return true;
+  }
+  /**
+   * Cleanup all timers and subscriptions.
+   */
+  dispose() {
+    for (const [, buffer] of this.batchBuffers) {
+      if (buffer.debounceTimer) clearTimeout(buffer.debounceTimer);
+      if (buffer.maxWaitTimer) clearTimeout(buffer.maxWaitTimer);
+    }
+    this.batchBuffers.clear();
+    this.sessionStates.clear();
+    this.inFlight.clear();
+    this.drainChains.clear();
+    if (this.redriveTimer) {
+      clearInterval(this.redriveTimer);
+      this.redriveTimer = null;
+    }
+    setRoutesChangeListener(void 0);
+    if (instance2 === this) instance2 = void 0;
+  }
+  // --- Private ---
+  async resolvePort(mindName) {
+    const entry = await findMind(mindName);
+    if (!entry) return null;
+    const baseName = entry.parent ?? mindName;
+    return { baseName, port: entry.port };
+  }
+  async postToMind(port, body) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 12e4);
+    try {
+      const res = await fetch(`http://127.0.0.1:${port}/message`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body,
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        dlog.warn(`mind responded ${res.status}: ${text}`);
+        return false;
+      }
+      await res.text().catch(() => {
+      });
+      return true;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  /**
+   * Serialize `fn` on a per-key promise chain so calls for the same key run one at a
+   * time in submission order. Used to drain a `(mind, session)` sequentially.
+   */
+  runSequential(key, fn) {
+    const prev = this.drainChains.get(key) ?? Promise.resolve();
+    const run = prev.then(fn, fn);
+    const tail = run.then(
+      () => {
+      },
+      () => {
+      }
+    );
+    this.drainChains.set(key, tail);
+    tail.then(() => {
+      if (this.drainChains.get(key) === tail) this.drainChains.delete(key);
+    });
+    return run;
+  }
+  /** Delete delivered queue rows by their specific ids. */
+  async deleteQueueRows(ids) {
+    const valid = [...new Set(ids.filter((id) => typeof id === "number"))];
+    if (valid.length === 0) return;
+    try {
+      const db = await getDb();
+      await db.delete(deliveryQueue).where(inArray(deliveryQueue.id, valid));
+    } catch (err) {
+      dlog.warn("failed to delete delivered delivery queue rows", logger_default.errorData(err));
+    }
+  }
+  /**
+   * Record the outcome of a failed delivery attempt: set a backoff window so the target
+   * isn't hot-looped, and — for a LIVE rejection — advance the dead-letter counter.
+   *
+   * Only a live rejection (`liveRejection: true`: the target was reachable and answered with
+   * a non-OK HTTP status) counts toward {@link MAX_DELIVERY_ATTEMPTS}. A transport failure
+   * (`liveRejection: false`: connection refused, reset, or timeout — the mind or a detached
+   * variant is simply down/unreachable) backs off WITHOUT advancing the counter, so a merely
+   * offline target is never dead-lettered and its message is preserved until it returns. The
+   * redrive guard only checks the base mind's up-ness, so a stopped variant reaches here on
+   * every sweep — this is what stops that from silently dropping its messages. #356
+   *
+   * A row that reaches the ceiling moves to the terminal `dead` status (excluded from
+   * redrive, which only reads `pending`) and the batch is surfaced as one failure notice.
+   *
+   * Rows here are still `inFlight` (the caller clears ownership in its own `finally`, after
+   * this resolves), so the concurrent redrive sweep skips them and can't race this update.
+   */
+  async scheduleRetry(ids, opts) {
+    const valid = [...new Set(ids.filter((id) => typeof id === "number"))];
+    if (valid.length === 0) return;
+    try {
+      const db = await getDb();
+      const rows = await db.select({
+        id: deliveryQueue.id,
+        attempts: deliveryQueue.attempts,
+        mind: deliveryQueue.mind,
+        target_mind: deliveryQueue.target_mind,
+        thread: deliveryQueue.thread,
+        channel: deliveryQueue.channel,
+        sender: deliveryQueue.sender,
+        created_at: deliveryQueue.created_at
+      }).from(deliveryQueue).where(inArray(deliveryQueue.id, valid));
+      const dead = [];
+      for (const row of rows) {
+        if (!opts.liveRejection) {
+          await db.update(deliveryQueue).set({ next_attempt_at: this.backoffExpr(row.attempts) }).where(eq2(deliveryQueue.id, row.id));
+          continue;
+        }
+        const attempts = row.attempts + 1;
+        if (attempts >= MAX_DELIVERY_ATTEMPTS) {
+          dlog.error(
+            `dead-lettering delivery queue row ${row.id} for ${row.mind} after ${attempts} live rejections (channel=${row.channel ?? "?"}, sender=${row.sender ?? "?"})`
+          );
+          const flipped = await db.update(deliveryQueue).set({ attempts, status: "dead", next_attempt_at: null }).where(and2(eq2(deliveryQueue.id, row.id), eq2(deliveryQueue.status, "pending"))).returning({ id: deliveryQueue.id });
+          if (flipped.length > 0) dead.push(row);
+          continue;
+        }
+        await db.update(deliveryQueue).set({ attempts, next_attempt_at: this.backoffExpr(attempts) }).where(eq2(deliveryQueue.id, row.id));
+      }
+      if (dead.length > 0) await this.notifyDeadLettered(dead);
+    } catch (err) {
+      dlog.error("failed to record delivery retry / dead-letter", logger_default.errorData(err));
+    }
+  }
+  /** Exponential backoff window (capped at {@link RETRY_MAX_MS}) as a SQL datetime expr. */
+  backoffExpr(attempts) {
+    const backoffSec = Math.round(
+      Math.min(RETRY_MAX_MS, RETRY_BASE_MS * 2 ** Math.min(attempts, 20)) / 1e3
+    );
+    return sql`datetime('now', ${`+${backoffSec} seconds`})`;
+  }
+  /**
+   * Surface a batch of dead-lettered rows as ONE next-turn failure notice, so a whole failing
+   * batch can't emit dozens of notices and evict unrelated ones via the per-thread overflow
+   * cap. The notice names the channel(s) and send times and points the mind at the surviving
+   * channel history, and never throws back into the delivery path — the rows are terminal. #356
+   */
+  async notifyDeadLettered(rows) {
+    const mind = rows[0].mind;
+    const threads = new Set(rows.map((r) => r.thread));
+    const single = threads.size === 1 ? [...threads][0] : MIND_LEVEL_THREAD;
+    const thread = single.startsWith("new-") ? MIND_LEVEL_THREAD : single;
+    const lines = rows.map((r) => {
+      const from = r.sender ? ` from ${r.sender}` : "";
+      const on = r.channel ? ` on ${r.channel}` : "";
+      const to = r.target_mind && r.target_mind !== r.mind ? ` to your variant ${r.target_mind}` : "";
+      return `- a message${from}${on}${to} (sent ${r.created_at})`;
+    });
+    const channels = [...new Set(rows.map((r) => r.channel).filter((c) => !!c))];
+    const recovery = channels.length > 0 ? `The original message(s) remain in the channel history \u2014 read them with ${channels.map((c) => `\`volute chat read ${c}\``).join(" or ")}.` : `The original message(s) remain in the channel history.`;
+    const detail = [
+      `${rows.length} message(s) sent to you could not be delivered after ${MAX_DELIVERY_ATTEMPTS} attempts and were dropped:`,
+      ...lines,
+      recovery
+    ].join("\n");
+    try {
+      await this.notifyFailure({
+        mind,
+        thread,
+        kind: "delivery_failed",
+        reason: "delivery_failed",
+        detail
+      });
+    } catch (err) {
+      dlog.warn(`failed to send dead-letter notice for ${mind}`, logger_default.errorData(err));
+    }
+  }
+  async deliverToMind(mindName, session, payload, sessionConfig, queueId) {
+    if (queueId != null) this.inFlight.add(queueId);
+    await this.runSequential(`${mindName}:${session}`, async () => {
+      const resolved = await this.resolvePort(mindName);
+      if (!resolved) {
+        dlog.warn(`cannot deliver to ${mindName}: mind not found`);
+        if (queueId != null) this.inFlight.delete(queueId);
+        return;
+      }
+      const { baseName, port } = resolved;
+      const senders = /* @__PURE__ */ new Set();
+      if (payload.sender) senders.add(payload.sender);
+      const channels = /* @__PURE__ */ new Set();
+      if (payload.channel) channels.add(payload.channel);
+      this.incrementActive(baseName, session, senders, channels);
+      await onDeliveredToMind(baseName, payload.conversationId);
+      linkInboundToActiveTurn(baseName, session, payload.channel).catch(
+        (err) => dlog.warn(`failed to link mid-turn inbound for ${baseName}`, logger_default.errorData(err))
+      );
+      const typingMap = getTypingMap();
+      if (payload.channel) {
+        typingMap.set(payload.channel, baseName, { persistent: true });
+      }
+      if (payload.conversationId) {
+        typingMap.set(payload.conversationId, baseName, { persistent: true });
+        publishTypingForChannels([payload.conversationId], typingMap);
+      }
+      onMindEvent(baseName, "delivery", payload.channel);
+      const enrichedPayload = await this.enrichWithProfiles(baseName, session, payload);
+      const body = JSON.stringify({
+        ...enrichedPayload,
+        session,
+        instructions: sessionConfig.instructions
+      });
+      try {
+        const ok = await this.postToMind(port, body);
+        if (!ok) {
+          this.decrementActive(baseName, session);
+          publishTypingForChannels(typingMap.deleteSender(baseName), typingMap);
+          await this.scheduleRetry([queueId], { liveRejection: true });
+        } else {
+          await this.deleteQueueRows([queueId]);
+        }
+      } catch (err) {
+        dlog.warn(`failed to deliver to ${mindName}`, logger_default.errorData(err));
+        this.decrementActive(baseName, session);
+        publishTypingForChannels(typingMap.deleteSender(baseName), typingMap);
+        await this.scheduleRetry([queueId], { liveRejection: false });
+      } finally {
+        if (queueId != null) this.inFlight.delete(queueId);
+      }
+    });
+  }
+  async deliverBatchToMind(mindName, session, messages2, sessionConfig) {
+    const queueIds = messages2.map((m) => m.queueId).filter((id) => typeof id === "number");
+    await this.runSequential(`${mindName}:${session}`, async () => {
+      const resolved = await this.resolvePort(mindName);
+      if (!resolved) {
+        dlog.warn(`cannot deliver batch to ${mindName}: mind not found`);
+        for (const id of queueIds) this.inFlight.delete(id);
+        return;
+      }
+      const { baseName, port } = resolved;
+      const firstPerChannel = /* @__PURE__ */ new Set();
+      const isFirstForChannel = [];
+      for (const msg of messages2) {
+        const ch = msg.channel ?? "unknown";
+        isFirstForChannel.push(!firstPerChannel.has(ch));
+        firstPerChannel.add(ch);
+      }
+      const enrichedMessages = await Promise.all(
+        messages2.map(async (msg, i) => {
+          if (!isFirstForChannel[i]) return msg;
+          const enrichedPayload = await this.enrichWithProfiles(baseName, session, msg.payload);
+          return { ...msg, payload: enrichedPayload };
+        })
+      );
+      const channels = {};
+      for (const msg of enrichedMessages) {
+        const ch = msg.channel ?? "unknown";
+        if (!channels[ch]) channels[ch] = [];
+        channels[ch].push(msg.payload);
+      }
+      const senders = /* @__PURE__ */ new Set();
+      const channelSet = /* @__PURE__ */ new Set();
+      for (const msg of messages2) {
+        if (msg.sender) senders.add(msg.sender);
+        if (msg.channel) channelSet.add(msg.channel);
+      }
+      this.incrementActive(baseName, session, senders, channelSet);
+      const convIds = /* @__PURE__ */ new Set();
+      for (const msg of messages2) {
+        if (msg.payload.conversationId) convIds.add(msg.payload.conversationId);
+      }
+      for (const convId of convIds) {
+        await onDeliveredToMind(baseName, convId);
+      }
+      for (const ch of channelSet) {
+        linkInboundToActiveTurn(baseName, session, ch).catch(
+          (err) => dlog.warn(`failed to link mid-turn inbound for ${baseName}`, logger_default.errorData(err))
+        );
+      }
+      const typingMap = getTypingMap();
+      for (const ch of Object.keys(channels)) {
+        if (ch !== "unknown") typingMap.set(ch, baseName, { persistent: true });
+      }
+      const seenConvIds = /* @__PURE__ */ new Set();
+      for (const msg of messages2) {
+        if (msg.payload.conversationId && !seenConvIds.has(msg.payload.conversationId)) {
+          seenConvIds.add(msg.payload.conversationId);
+          typingMap.set(msg.payload.conversationId, baseName, { persistent: true });
+        }
+      }
+      if (seenConvIds.size > 0) {
+        publishTypingForChannels([...seenConvIds], typingMap);
+      }
+      const body = JSON.stringify({
+        session,
+        batch: { channels },
+        instructions: sessionConfig.instructions
+      });
+      try {
+        const ok = await this.postToMind(port, body);
+        if (!ok) {
+          this.decrementActive(baseName, session);
+          publishTypingForChannels(typingMap.deleteSender(baseName), typingMap);
+          await this.scheduleRetry(queueIds, { liveRejection: true });
+        } else {
+          await this.deleteQueueRows(queueIds);
+        }
+      } catch (err) {
+        dlog.warn(`failed to deliver batch to ${mindName}`, logger_default.errorData(err));
+        this.decrementActive(baseName, session);
+        publishTypingForChannels(typingMap.deleteSender(baseName), typingMap);
+        await this.scheduleRetry(queueIds, { liveRejection: false });
+      } finally {
+        for (const id of queueIds) this.inFlight.delete(id);
+      }
+    });
+  }
+  async enqueueBatch(mindName, session, payload, sessionConfig) {
+    const delivery = sessionConfig.delivery;
+    const queueId = await this.persistToQueue(mindName, session, payload);
+    if (queueId != null) this.inFlight.add(queueId);
+    const msg = {
+      payload,
+      channel: payload.channel,
+      sender: payload.sender ?? null,
+      createdAt: Date.now(),
+      queueId
+    };
+    if (delivery.triggers?.length) {
+      const text = extractTextContent(payload.content);
+      const lower = text.toLowerCase();
+      if (delivery.triggers.some((t) => lower.includes(t.toLowerCase()))) {
+        await this.flushBatch(mindName, session, [msg]);
+        return;
+      }
+    }
+    this.addToBatchBuffer(mindName, session, sessionConfig, msg);
+  }
+  addToBatchBuffer(mindName, session, sessionConfig, msg) {
+    const delivery = sessionConfig.delivery;
+    const bufferKey = `${mindName}:${session}`;
+    let buffer = this.batchBuffers.get(bufferKey);
+    if (!buffer) {
+      buffer = {
+        messages: [],
+        debounceTimer: null,
+        maxWaitTimer: null,
+        delivery
+      };
+      this.batchBuffers.set(bufferKey, buffer);
+    }
+    buffer.messages.push(msg);
+    if (buffer.messages.length >= MAX_BATCH_SIZE) {
+      this.flushBatch(mindName, session);
+      return;
+    }
+    this.scheduleBatchTimers(mindName, session, bufferKey);
+  }
+  scheduleBatchTimers(mindName, session, bufferKey) {
+    const buffer = this.batchBuffers.get(bufferKey);
+    if (!buffer) return;
+    if (buffer.debounceTimer) clearTimeout(buffer.debounceTimer);
+    buffer.debounceTimer = setTimeout(() => {
+      if (!this.isSessionBusy(mindName, session)) {
+        this.flushBatch(mindName, session);
+      }
+    }, buffer.delivery.debounce * 1e3);
+    buffer.debounceTimer.unref();
+    if (!buffer.maxWaitTimer) {
+      buffer.maxWaitTimer = setTimeout(() => {
+        this.flushBatch(mindName, session);
+      }, buffer.delivery.maxWait * 1e3);
+      buffer.maxWaitTimer.unref();
+    }
+  }
+  async flushBatch(mindName, session, extra) {
+    const bufferKey = `${mindName}:${session}`;
+    const buffer = this.batchBuffers.get(bufferKey);
+    const messages2 = [];
+    if (buffer) {
+      if (buffer.debounceTimer) clearTimeout(buffer.debounceTimer);
+      if (buffer.maxWaitTimer) clearTimeout(buffer.maxWaitTimer);
+      buffer.debounceTimer = null;
+      buffer.maxWaitTimer = null;
+      messages2.push(...buffer.messages.splice(0));
+      this.batchBuffers.delete(bufferKey);
+    }
+    if (extra) messages2.push(...extra);
+    if (messages2.length === 0) return;
+    const baseName = await getBaseName(mindName);
+    const config = getRoutingConfig(baseName);
+    const sessionConfig = resolveDeliveryMode(config, session);
+    dlog.info(`flushing batch for ${mindName}/${session}: ${messages2.length} messages`);
+    this.deliverBatchToMind(mindName, session, messages2, sessionConfig).catch((err) => {
+      dlog.warn(`failed to flush batch for ${mindName}/${session}`, logger_default.errorData(err));
+    });
+  }
+  async gateMessage(mindName, session, payload) {
+    const baseName = await getBaseName(mindName);
+    const declined = await this.isChannelDeclined(baseName, payload.channel);
+    await this.persistToQueue(mindName, session, payload, declined ? "archived" : "gated");
+    if (declined) return;
+    try {
+      const db = await getDb();
+      const rows = await db.select({ count: sql`count(*)` }).from(deliveryQueue).where(
+        and2(
+          eq2(deliveryQueue.mind, baseName),
+          eq2(deliveryQueue.channel, payload.channel),
+          inArray(deliveryQueue.status, ["gated", "archived"])
+        )
+      );
+      const count = rows[0]?.count ?? 0;
+      if (count === 1 || count % GATED_NOTIFY_EVERY === 0) {
+        await this.sendInviteNotification(mindName, payload, count);
+      }
+    } catch (err) {
+      dlog.warn(`failed to check gated count for ${baseName}`, logger_default.errorData(err));
+    }
+  }
+  async sendInviteNotification(mindName, payload, gatedCount = 1) {
+    const text = extractTextContent(payload.content);
+    const preview = text.length > 200 ? `${text.slice(0, 200)}...` : text;
+    const channel = payload.channel ?? "unknown";
+    const heldLine = gatedCount > 1 ? `${gatedCount} messages from this channel are being held, unrouted \u2014 you've not routed it yet.` : `Someone new is reaching out \u2014 you don't have a route for this channel yet.`;
+    const detailLines = [
+      payload.platform ? `Platform: ${payload.platform}` : null,
+      payload.participantCount ? `Participants: ${payload.participantCount}` : null
+    ].filter((l) => l !== null);
+    const details = detailLines.length > 0 ? `${detailLines.join("\n")}
+
+` : "\n";
+    const { getPrompt } = await import("./prompts-NBO3HRK3.js");
+    const notification = await getPrompt("channel_invite", {
+      channel,
+      heldLine,
+      sender: payload.sender ?? "unknown",
+      details,
+      preview,
+      limit: String(GATED_RELEASE_LIMIT_PER_CHANNEL)
+    });
+    await this.notify(mindName, notification);
+  }
+  /**
+   * Insert a delivery_queue row and return its id. The `mind` column is always keyed by
+   * `baseName` so inserts under a variant name and the id-scoped cleanup use the same key
+   * (fixes the variant mismatch where variant-keyed rows were never matched by the base
+   * cleanup). `target_mind` records the original delivery target (`mindName`, which may be a
+   * variant) so redrive resolves the port from it — a variant's stranded row is re-delivered
+   * to the variant, not the parent.
+   */
+  async persistToQueue(mindName, session, payload, status = "pending") {
+    try {
+      const baseName = await getBaseName(mindName);
+      const db = await getDb();
+      const result = await db.insert(deliveryQueue).values({
+        mind: baseName,
+        target_mind: mindName,
+        thread: session,
+        channel: payload.channel ?? null,
+        sender: payload.sender ?? null,
+        status,
+        payload: JSON.stringify(payload)
+      }).returning({ id: deliveryQueue.id });
+      return result[0]?.id;
+    } catch (err) {
+      dlog.warn(
+        `failed to persist to delivery queue for ${mindName}/${session}`,
+        logger_default.errorData(err)
+      );
+      return void 0;
+    }
+  }
+  async enrichWithProfiles(mindName, session, payload) {
+    if (!payload.conversationId || !payload.channel) return payload;
+    const mindSessions = this.sessionStates.get(mindName);
+    const state2 = mindSessions?.get(session);
+    if (!state2) return payload;
+    const channelKey = payload.channel;
+    if (state2.seenChannelProfiles.has(channelKey)) return payload;
+    try {
+      const participants = await getParticipants(payload.conversationId);
+      const profiles = participants.map((p) => ({
+        username: p.username,
+        userType: p.userType,
+        displayName: p.displayName,
+        description: p.description
+      }));
+      const avatarBlocks = await this.loadAvatarBlocks(participants);
+      state2.seenChannelProfiles.add(channelKey);
+      const enriched = { ...payload, participantProfiles: profiles };
+      if (avatarBlocks.length > 0) {
+        const existing = Array.isArray(payload.content) ? payload.content : typeof payload.content === "string" ? [{ type: "text", text: payload.content }] : [];
+        enriched.content = [...avatarBlocks, ...existing];
+      }
+      return enriched;
+    } catch (err) {
+      dlog.warn(`failed to fetch participant profiles for ${mindName}`, logger_default.errorData(err));
+      return payload;
+    }
+  }
+  async loadAvatarBlocks(participants) {
+    const cacheKey = participants.map((p) => `${p.username}:${p.avatar ?? ""}`).sort().join(",");
+    const cached = avatarBlocksCache.get(cacheKey);
+    if (cached && cached.expiresAt > Date.now()) return cached.blocks;
+    const blocks = [];
+    for (const p of participants) {
+      if (!p.avatar) continue;
+      try {
+        let filePath;
+        if (p.userType === "mind") {
+          const dir = mindDir(p.username);
+          const config = readVoluteConfig(dir);
+          if (!config?.profile?.avatar) continue;
+          filePath = resolve(dir, "home", config.profile.avatar);
+          const homeDir = resolve(dir, "home");
+          if (!filePath.startsWith(`${homeDir}/`)) {
+            dlog.warn(`avatar path for ${p.username} escapes home directory, skipping`);
+            continue;
+          }
+          try {
+            const realHome = await realpath(homeDir);
+            const realAvatar = await realpath(filePath);
+            if (!realAvatar.startsWith(`${realHome}/`)) {
+              dlog.warn(
+                `avatar symlink for ${p.username} resolves outside home directory, skipping`
+              );
+              continue;
+            }
+          } catch (err) {
+            if (err.code === "ENOENT") continue;
+            throw err;
+          }
+        } else {
+          filePath = resolve(voluteHome(), "avatars", p.avatar);
+        }
+        const rendered = await renderAvatarBlock(filePath, p.username);
+        if (rendered) blocks.push(...rendered);
+      } catch (err) {
+        const code = err.code;
+        if (code !== "ENOENT") {
+          dlog.warn(`failed to load avatar for ${p.username}`, logger_default.errorData(err));
+        }
+      }
+    }
+    const now = Date.now();
+    for (const [key, entry] of avatarBlocksCache) {
+      if (entry.expiresAt <= now) avatarBlocksCache.delete(key);
+    }
+    avatarBlocksCache.set(cacheKey, { blocks, expiresAt: now + AVATAR_CACHE_TTL });
+    return blocks;
+  }
+  incrementActive(mind, session, senders, channels) {
+    let mindSessions = this.sessionStates.get(mind);
+    if (!mindSessions) {
+      mindSessions = /* @__PURE__ */ new Map();
+      this.sessionStates.set(mind, mindSessions);
+    }
+    const state2 = mindSessions.get(session) ?? {
+      activeCount: 0,
+      lastDeliveredAt: 0,
+      lastDeliverySenders: /* @__PURE__ */ new Set(),
+      lastDeliveryChannels: /* @__PURE__ */ new Set(),
+      seenChannelProfiles: /* @__PURE__ */ new Set()
+    };
+    state2.activeCount++;
+    state2.lastDeliveredAt = Date.now();
+    if (senders) state2.lastDeliverySenders = senders;
+    if (channels) state2.lastDeliveryChannels = channels;
+    mindSessions.set(session, state2);
+  }
+  decrementActive(mind, session) {
+    const mindSessions = this.sessionStates.get(mind);
+    if (!mindSessions) return;
+    const state2 = mindSessions.get(session);
+    if (!state2) return;
+    state2.activeCount = Math.max(0, state2.activeCount - 1);
+    if (state2.activeCount === 0) {
+      const bufferKey = `${mind}:${session}`;
+      const buffer = this.batchBuffers.get(bufferKey);
+      if (buffer && buffer.messages.length > 0) {
+        this.scheduleBatchTimers(mind, session, bufferKey);
+      } else if (session.startsWith("new-")) {
+        mindSessions.delete(session);
+        if (mindSessions.size === 0) this.sessionStates.delete(mind);
+      }
+    }
+  }
+};
+var instance2;
+function initDeliveryManager() {
+  if (instance2) throw new Error("DeliveryManager already initialized");
+  instance2 = new DeliveryManager();
+  return instance2;
+}
+function getDeliveryManager() {
+  if (!instance2) {
+    throw new Error("DeliveryManager not initialized \u2014 call initDeliveryManager() first");
+  }
+  return instance2;
+}
+function tryGetDeliveryManager() {
+  return instance2;
+}
+
+export {
+  getTypingMap,
+  isConversationId,
+  publishTypingForChannels,
+  checkStaleSend,
+  formatHoldNotice,
+  MAX_DELIVERY_ATTEMPTS,
+  DeliveryManager,
+  initDeliveryManager,
+  getDeliveryManager,
+  tryGetDeliveryManager
+};