volute 0.19.0 → 0.21.0

package/dist/{chunk-FGV2H4TX.js → chunk-OGZYB5GL.js}

@@ -1,41 +1,173 @@
 #!/usr/bin/env node
-import {
-  logger_default
-} from "./chunk-YUIHSKR6.js";
-import {
-  getDb
-} from "./chunk-Z524RFCJ.js";
 import {
   deliveryQueue,
+  getDb,
   mindHistory
-} from "./chunk-VQWDC6UK.js";
+} from "./chunk-SGPEZ32F.js";
+import {
+  logger_default
+} from "./chunk-YUIHSKR6.js";
 import {
   findMind,
   findVariant,
   mindDir
-} from "./chunk-EBGCNDMM.js";
+} from "./chunk-B2CPS4QU.js";
 
-// src/lib/delivery-manager.ts
+// src/lib/delivery/delivery-manager.ts
 import { and, eq, sql } from "drizzle-orm";
 
-// src/lib/delivery-router.ts
+// src/lib/events/conversation-events.ts
+var subscribers = /* @__PURE__ */ new Map();
+function subscribe(conversationId, callback) {
+  let set = subscribers.get(conversationId);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    subscribers.set(conversationId, set);
+  }
+  set.add(callback);
+  return () => {
+    set.delete(callback);
+    if (set.size === 0) subscribers.delete(conversationId);
+  };
+}
+function publish(conversationId, event) {
+  const set = subscribers.get(conversationId);
+  if (!set) return;
+  for (const cb of set) {
+    try {
+      cb(event);
+    } catch (err) {
+      console.error("[conversation-events] subscriber threw:", err);
+      set.delete(cb);
+      if (set.size === 0) subscribers.delete(conversationId);
+    }
+  }
+}
+
+// src/lib/typing.ts
+var DEFAULT_TTL_MS = 1e4;
+var SWEEP_INTERVAL_MS = 5e3;
+var VOLUTE_PREFIX = "volute:";
+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 publishTypingForChannels(channels, map) {
+  for (const channel of channels) {
+    if (channel.startsWith(VOLUTE_PREFIX)) {
+      const conversationId = channel.slice(VOLUTE_PREFIX.length);
+      publish(conversationId, { type: "typing", senders: map.get(channel) });
+    }
+  }
+}
+
+// src/lib/delivery/delivery-router.ts
 import { readFileSync, statSync } from "fs";
 import { resolve } from "path";
+function extractTextContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter((p) => p.type === "text" && p.text).map((p) => p.text).join("\n");
+  }
+  return JSON.stringify(content);
+}
 var configCache = /* @__PURE__ */ new Map();
+var statCheckCache = /* @__PURE__ */ new Map();
+var STAT_TTL_MS = 5e3;
 var dlog = logger_default.child("delivery-router");
 function configPath(mindName) {
   return resolve(mindDir(mindName), "home/.config/routes.json");
 }
 function getRoutingConfig(mindName) {
   const path = configPath(mindName);
+  const now = Date.now();
+  const statCached = statCheckCache.get(mindName);
+  const cached = configCache.get(mindName);
+  if (statCached && cached && now - statCached.checkedAt < STAT_TTL_MS) {
+    return cached.config;
+  }
   let mtime;
   try {
     mtime = statSync(path).mtimeMs;
   } catch {
     configCache.delete(mindName);
+    statCheckCache.delete(mindName);
     return {};
   }
-  const cached = configCache.get(mindName);
+  statCheckCache.set(mindName, { mtime, checkedAt: now });
   if (cached && cached.mtime === mtime) {
     return cached.config;
   }
@@ -50,9 +182,15 @@ function getRoutingConfig(mindName) {
     return {};
   }
 }
+var globRegexCache = /* @__PURE__ */ new Map();
 function globMatch(pattern, value) {
-  const regex = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-  return new RegExp(`^${regex}$`).test(value);
+  let regex = globRegexCache.get(pattern);
+  if (!regex) {
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    regex = new RegExp(`^${escaped}$`);
+    globRegexCache.set(pattern, regex);
+  }
+  return regex.test(value);
 }
 var GLOB_MATCH_KEYS = /* @__PURE__ */ new Set(["channel", "sender"]);
 var NON_MATCH_KEYS = /* @__PURE__ */ new Set(["session", "destination", "path", "mode"]);
@@ -164,162 +302,8 @@ function resolveDeliveryMode(config, sessionName) {
   return defaults;
 }
 
-// src/lib/message-delivery.ts
-var dlog2 = logger_default.child("delivery");
-function extractTextContent(content) {
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content.filter((p) => p.type === "text" && p.text).map((p) => p.text).join("\n");
-  }
-  return JSON.stringify(content);
-}
-async function deliverMessage(mindName, payload) {
-  try {
-    const [baseName] = mindName.split("@", 2);
-    const entry = findMind(baseName);
-    if (!entry) {
-      dlog2.warn(`cannot deliver to ${mindName}: mind not found`);
-      return;
-    }
-    const textContent = extractTextContent(payload.content);
-    try {
-      const db = await getDb();
-      await db.insert(mindHistory).values({
-        mind: baseName,
-        type: "inbound",
-        channel: payload.channel,
-        sender: payload.sender ?? null,
-        content: textContent
-      });
-    } catch (err) {
-      dlog2.warn(`failed to persist message for ${baseName}`, logger_default.errorData(err));
-    }
-    try {
-      const { getDeliveryManager: getDeliveryManager2 } = await import("./delivery-manager-ISTJMZDW.js");
-      const manager = getDeliveryManager2();
-      await manager.routeAndDeliver(mindName, payload);
-      return;
-    } catch (err) {
-      if (err instanceof Error && !err.message.includes("not initialized")) {
-        dlog2.warn("delivery manager error, falling back to direct delivery", logger_default.errorData(err));
-      }
-    }
-    const { findVariant: findVariant2 } = await import("./variants-JAGWGBXG.js");
-    const [, variantName] = mindName.split("@", 2);
-    let port = entry.port;
-    if (variantName) {
-      const variant = findVariant2(baseName, variantName);
-      if (!variant) {
-        dlog2.warn(`cannot deliver to ${mindName}: variant not found`);
-        return;
-      }
-      port = variant.port;
-    }
-    const body = JSON.stringify(payload);
-    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(() => "");
-        dlog2.warn(`mind ${mindName} responded ${res.status}: ${text}`);
-      } else {
-        await res.text().catch(() => {
-        });
-      }
-    } catch (err) {
-      dlog2.warn(`failed to deliver to ${mindName}`, logger_default.errorData(err));
-    } finally {
-      clearTimeout(timeout);
-    }
-  } catch (err) {
-    dlog2.warn(`unexpected error delivering to ${mindName}`, logger_default.errorData(err));
-  }
-}
-
-// src/lib/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). */
-  deleteSender(sender) {
-    for (const [channel, senders] of this.channels) {
-      senders.delete(sender);
-      if (senders.size === 0) {
-        this.channels.delete(channel);
-      }
-    }
-  }
-  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;
-}
-
-// src/lib/delivery-manager.ts
-var dlog3 = logger_default.child("delivery-manager");
+// src/lib/delivery/delivery-manager.ts
+var dlog2 = logger_default.child("delivery-manager");
 var MAX_BATCH_SIZE = 50;
 var DeliveryManager = class {
   sessionStates = /* @__PURE__ */ new Map();
@@ -396,7 +380,7 @@ var DeliveryManager = class {
         try {
           payload = JSON.parse(row.payload);
         } catch (parseErr) {
-          dlog3.warn(
+          dlog2.warn(
             `corrupt payload in delivery queue row ${row.id}, skipping`,
             logger_default.errorData(parseErr)
           );
@@ -407,22 +391,21 @@ var DeliveryManager = class {
         if (sessionConfig.delivery.mode === "batch") {
           this.addToBatchBuffer(row.mind, row.session, payload, sessionConfig);
         } else {
-          this.deliverToMind(row.mind, row.session, payload, sessionConfig).then(async () => {
-            try {
-              const db2 = await getDb();
-              await db2.delete(deliveryQueue).where(eq(deliveryQueue.id, row.id));
-            } catch {
-            }
-          }).catch((err) => {
-            dlog3.warn(`failed to restore delivery for ${row.mind}`, logger_default.errorData(err));
+          try {
+            await db.delete(deliveryQueue).where(eq(deliveryQueue.id, row.id));
+          } catch (err) {
+            dlog2.warn(`failed to delete queue row ${row.id} for ${row.mind}`, logger_default.errorData(err));
+          }
+          this.deliverToMind(row.mind, row.session, payload, sessionConfig).catch((err) => {
+            dlog2.warn(`failed to restore delivery for ${row.mind}`, logger_default.errorData(err));
           });
         }
       }
       if (rows.length > 0) {
-        dlog3.info(`restored ${rows.length} queued messages from DB`);
+        dlog2.info(`restored ${rows.length} queued messages from DB`);
       }
     } catch (err) {
-      dlog3.warn("failed to restore delivery queue from DB", logger_default.errorData(err));
+      dlog2.warn("failed to restore delivery queue from DB", logger_default.errorData(err));
     }
   }
   /**
@@ -471,34 +454,18 @@ var DeliveryManager = class {
     if (instance2 === this) instance2 = void 0;
   }
   // --- Private ---
-  async deliverToMind(mindName, session, payload, sessionConfig) {
+  resolvePort(mindName) {
     const [baseName, variantName] = mindName.split("@", 2);
     const entry = findMind(baseName);
-    if (!entry) {
-      dlog3.warn(`cannot deliver to ${mindName}: mind not found`);
-      return;
-    }
-    let port = entry.port;
+    if (!entry) return null;
     if (variantName) {
       const variant = findVariant(baseName, variantName);
-      if (!variant) {
-        dlog3.warn(`cannot deliver to ${mindName}: variant not found`);
-        return;
-      }
-      port = variant.port;
+      if (!variant) return null;
+      return { baseName, port: variant.port };
     }
-    this.incrementActive(baseName, session);
-    const typingMap = getTypingMap();
-    if (payload.channel) {
-      typingMap.set(payload.channel, baseName, { persistent: true });
-    }
-    const deliveryBody = {
-      ...payload,
-      session,
-      interrupt: sessionConfig.interrupt,
-      instructions: sessionConfig.instructions
-    };
-    const body = JSON.stringify(deliveryBody);
+    return { baseName, port: entry.port };
+  }
+  async postToMind(port, body) {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 12e4);
     try {
@@ -510,74 +477,96 @@ var DeliveryManager = class {
       });
       if (!res.ok) {
         const text = await res.text().catch(() => "");
-        dlog3.warn(`mind ${mindName} responded ${res.status}: ${text}`);
-        this.decrementActive(baseName, session);
-        if (payload.channel) typingMap.delete(payload.channel, baseName);
-      } else {
-        await res.text().catch(() => {
-        });
+        dlog2.warn(`mind responded ${res.status}: ${text}`);
+        return false;
       }
-    } catch (err) {
-      dlog3.warn(`failed to deliver to ${mindName}`, logger_default.errorData(err));
-      this.decrementActive(baseName, session);
-      if (payload.channel) typingMap.delete(payload.channel, baseName);
+      await res.text().catch(() => {
+      });
+      return true;
     } finally {
       clearTimeout(timeout);
     }
   }
-  async deliverBatchToMind(mindName, session, messages, sessionConfig) {
-    const [baseName, variantName] = mindName.split("@", 2);
-    const entry = findMind(baseName);
-    if (!entry) {
-      dlog3.warn(`cannot deliver batch to ${mindName}: mind not found`);
+  async deliverToMind(mindName, session, payload, sessionConfig) {
+    const resolved = this.resolvePort(mindName);
+    if (!resolved) {
+      dlog2.warn(`cannot deliver to ${mindName}: mind not found`);
       return;
     }
-    let port = entry.port;
-    if (variantName) {
-      const variant = findVariant(baseName, variantName);
-      if (!variant) {
-        dlog3.warn(`cannot deliver batch to ${mindName}: variant not found`);
-        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);
+    const typingMap = getTypingMap();
+    if (payload.channel) {
+      typingMap.set(payload.channel, baseName, { persistent: true });
+    }
+    if (payload.conversationId) {
+      typingMap.set(`volute:${payload.conversationId}`, baseName, { persistent: true });
+    }
+    const body = JSON.stringify({
+      ...payload,
+      session,
+      interrupt: sessionConfig.interrupt,
+      instructions: sessionConfig.instructions
+    });
+    try {
+      const ok = await this.postToMind(port, body);
+      if (!ok) {
+        this.decrementActive(baseName, session);
+        publishTypingForChannels(typingMap.deleteSender(baseName), typingMap);
       }
-      port = variant.port;
+    } catch (err) {
+      dlog2.warn(`failed to deliver to ${mindName}`, logger_default.errorData(err));
+      this.decrementActive(baseName, session);
+      publishTypingForChannels(typingMap.deleteSender(baseName), typingMap);
     }
+  }
+  async deliverBatchToMind(mindName, session, messages, sessionConfig, interruptOverride) {
+    const resolved = this.resolvePort(mindName);
+    if (!resolved) {
+      dlog2.warn(`cannot deliver batch to ${mindName}: mind not found`);
+      return;
+    }
+    const { baseName, port } = resolved;
     const channels = {};
     for (const msg of messages) {
       const ch = msg.channel ?? "unknown";
       if (!channels[ch]) channels[ch] = [];
       channels[ch].push(msg.payload);
     }
-    this.incrementActive(baseName, session);
+    const senders = /* @__PURE__ */ new Set();
+    const channelSet = /* @__PURE__ */ new Set();
+    for (const msg of messages) {
+      if (msg.sender) senders.add(msg.sender);
+      if (msg.channel) channelSet.add(msg.channel);
+    }
+    this.incrementActive(baseName, session, senders, channelSet);
     const typingMap = getTypingMap();
     for (const ch of Object.keys(channels)) {
       if (ch !== "unknown") typingMap.set(ch, baseName, { persistent: true });
     }
-    const batchBody = {
+    const seenConvIds = /* @__PURE__ */ new Set();
+    for (const msg of messages) {
+      if (msg.payload.conversationId && !seenConvIds.has(msg.payload.conversationId)) {
+        seenConvIds.add(msg.payload.conversationId);
+        typingMap.set(`volute:${msg.payload.conversationId}`, baseName, { persistent: true });
+      }
+    }
+    const body = JSON.stringify({
       session,
       batch: { channels },
-      interrupt: sessionConfig.interrupt,
+      interrupt: interruptOverride ?? sessionConfig.interrupt,
       instructions: sessionConfig.instructions
-    };
-    const body = JSON.stringify(batchBody);
-    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(() => "");
-        dlog3.warn(`mind ${mindName} batch responded ${res.status}: ${text}`);
+      const ok = await this.postToMind(port, body);
+      if (!ok) {
         this.decrementActive(baseName, session);
-        for (const ch of Object.keys(channels)) {
-          typingMap.delete(ch, baseName);
-        }
+        publishTypingForChannels(typingMap.deleteSender(baseName), typingMap);
       } else {
-        await res.text().catch(() => {
-        });
         try {
           const db = await getDb();
           await db.delete(deliveryQueue).where(
@@ -588,20 +577,16 @@ var DeliveryManager = class {
             )
           );
         } catch (err) {
-          dlog3.warn(
+          dlog2.warn(
             `failed to clean delivery queue for ${baseName}/${session}`,
             logger_default.errorData(err)
           );
         }
       }
     } catch (err) {
-      dlog3.warn(`failed to deliver batch to ${mindName}`, logger_default.errorData(err));
+      dlog2.warn(`failed to deliver batch to ${mindName}`, logger_default.errorData(err));
       this.decrementActive(baseName, session);
-      for (const ch of Object.keys(channels)) {
-        typingMap.delete(ch, baseName);
-      }
-    } finally {
-      clearTimeout(timeout);
+      publishTypingForChannels(typingMap.deleteSender(baseName), typingMap);
     }
   }
   enqueueBatch(mindName, session, payload, sessionConfig) {
@@ -621,8 +606,23 @@ var DeliveryManager = class {
         return;
       }
     }
+    const [baseName] = mindName.split("@", 2);
+    const state = this.sessionStates.get(baseName)?.get(session);
+    if (state && state.activeCount > 0 && payload.sender && !state.lastDeliverySenders.has(payload.sender) && payload.channel && state.lastDeliveryChannels.has(payload.channel) && Date.now() - state.lastDeliveredAt < delivery.maxWait * 1e3 && Date.now() - state.lastInterruptAt > delivery.debounce * 1e3) {
+      state.lastInterruptAt = Date.now();
+      this.persistToQueue(mindName, session, payload).catch((err) => {
+        dlog2.warn(`failed to persist batch message for ${mindName}/${session}`, logger_default.errorData(err));
+      });
+      this.flushBatch(
+        mindName,
+        session,
+        [{ payload, channel: payload.channel, sender: payload.sender, createdAt: Date.now() }],
+        true
+      );
+      return;
+    }
     this.persistToQueue(mindName, session, payload).catch((err) => {
-      dlog3.warn(`failed to persist batch message for ${mindName}/${session}`, logger_default.errorData(err));
+      dlog2.warn(`failed to persist batch message for ${mindName}/${session}`, logger_default.errorData(err));
     });
     this.addToBatchBuffer(mindName, session, payload, sessionConfig);
   }
@@ -668,7 +668,7 @@ var DeliveryManager = class {
       buffer.maxWaitTimer.unref();
     }
   }
-  flushBatch(mindName, session, extra) {
+  flushBatch(mindName, session, extra, interruptOverride) {
     const bufferKey = `${mindName}:${session}`;
     const buffer = this.batchBuffers.get(bufferKey);
     const messages = [];
@@ -685,10 +685,14 @@ var DeliveryManager = class {
     const [baseName] = mindName.split("@", 2);
     const config = getRoutingConfig(baseName);
     const sessionConfig = resolveDeliveryMode(config, session);
-    dlog3.info(`flushing batch for ${mindName}/${session}: ${messages.length} messages`);
-    this.deliverBatchToMind(mindName, session, messages, sessionConfig).catch((err) => {
-      dlog3.warn(`failed to flush batch for ${mindName}/${session}`, logger_default.errorData(err));
-    });
+    dlog2.info(
+      `flushing batch for ${mindName}/${session}: ${messages.length} messages${interruptOverride ? " (new-speaker interrupt)" : ""}`
+    );
+    this.deliverBatchToMind(mindName, session, messages, sessionConfig, interruptOverride).catch(
+      (err) => {
+        dlog2.warn(`failed to flush batch for ${mindName}/${session}`, logger_default.errorData(err));
+      }
+    );
   }
   async gateMessage(mindName, session, payload) {
     const [baseName] = mindName.split("@", 2);
@@ -706,7 +710,7 @@ var DeliveryManager = class {
         await this.sendInviteNotification(mindName, payload);
       }
     } catch (err) {
-      dlog3.warn(`failed to check gated count for ${baseName}`, logger_default.errorData(err));
+      dlog2.warn(`failed to check gated count for ${baseName}`, logger_default.errorData(err));
     }
   }
   async sendInviteNotification(mindName, payload) {
@@ -748,21 +752,29 @@ var DeliveryManager = class {
         payload: JSON.stringify(payload)
       });
     } catch (err) {
-      dlog3.warn(
+      dlog2.warn(
         `failed to persist to delivery queue for ${mindName}/${session}`,
         logger_default.errorData(err)
       );
     }
   }
-  incrementActive(mind, session) {
+  incrementActive(mind, session, senders, channels) {
     let mindSessions = this.sessionStates.get(mind);
     if (!mindSessions) {
       mindSessions = /* @__PURE__ */ new Map();
       this.sessionStates.set(mind, mindSessions);
     }
-    const state = mindSessions.get(session) ?? { activeCount: 0, lastDeliveredAt: 0 };
+    const state = mindSessions.get(session) ?? {
+      activeCount: 0,
+      lastDeliveredAt: 0,
+      lastDeliverySenders: /* @__PURE__ */ new Set(),
+      lastDeliveryChannels: /* @__PURE__ */ new Set(),
+      lastInterruptAt: 0
+    };
     state.activeCount++;
     state.lastDeliveredAt = Date.now();
+    if (senders) state.lastDeliverySenders = senders;
+    if (channels) state.lastDeliveryChannels = channels;
     mindSessions.set(session, state);
   }
   decrementActive(mind, session) {
@@ -782,7 +794,7 @@ var DeliveryManager = class {
 };
 var instance2;
 function initDeliveryManager() {
-  if (instance2) return instance2;
+  if (instance2) throw new Error("DeliveryManager already initialized");
   instance2 = new DeliveryManager();
   return instance2;
 }
@@ -793,11 +805,43 @@ function getDeliveryManager() {
   return instance2;
 }
 
+// src/lib/delivery/message-delivery.ts
+var dlog3 = logger_default.child("delivery");
+async function deliverMessage(mindName, payload) {
+  try {
+    const [baseName] = mindName.split("@", 2);
+    const entry = findMind(baseName);
+    if (!entry) {
+      dlog3.warn(`cannot deliver to ${mindName}: mind not found`);
+      return;
+    }
+    const textContent = extractTextContent(payload.content);
+    try {
+      const db = await getDb();
+      await db.insert(mindHistory).values({
+        mind: baseName,
+        type: "inbound",
+        channel: payload.channel,
+        sender: payload.sender ?? null,
+        content: textContent
+      });
+    } catch (err) {
+      dlog3.warn(`failed to persist message for ${baseName}`, logger_default.errorData(err));
+    }
+    const manager = getDeliveryManager();
+    await manager.routeAndDeliver(mindName, payload);
+  } catch (err) {
+    dlog3.warn(`unexpected error delivering to ${mindName}`, logger_default.errorData(err));
+  }
+}
+
 export {
-  extractTextContent,
-  deliverMessage,
+  subscribe,
+  publish,
   getTypingMap,
-  DeliveryManager,
+  publishTypingForChannels,
+  extractTextContent,
   initDeliveryManager,
-  getDeliveryManager
+  getDeliveryManager,
+  deliverMessage
 };