volute 0.18.0 → 0.19.0

package/dist/chunk-FGV2H4TX.js

@@ -0,0 +1,803 @@
+#!/usr/bin/env node
+import {
+  logger_default
+} from "./chunk-YUIHSKR6.js";
+import {
+  getDb
+} from "./chunk-Z524RFCJ.js";
+import {
+  deliveryQueue,
+  mindHistory
+} from "./chunk-VQWDC6UK.js";
+import {
+  findMind,
+  findVariant,
+  mindDir
+} from "./chunk-EBGCNDMM.js";
+
+// src/lib/delivery-manager.ts
+import { and, eq, sql } from "drizzle-orm";
+
+// src/lib/delivery-router.ts
+import { readFileSync, statSync } from "fs";
+import { resolve } from "path";
+var configCache = /* @__PURE__ */ new Map();
+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);
+  let mtime;
+  try {
+    mtime = statSync(path).mtimeMs;
+  } catch {
+    configCache.delete(mindName);
+    return {};
+  }
+  const cached = configCache.get(mindName);
+  if (cached && cached.mtime === mtime) {
+    return cached.config;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    const config = Array.isArray(parsed) ? { rules: parsed } : parsed;
+    configCache.set(mindName, { config, mtime });
+    return config;
+  } catch (err) {
+    dlog.warn(`failed to load routes.json for ${mindName}`, logger_default.errorData(err));
+    configCache.delete(mindName);
+    return {};
+  }
+}
+function globMatch(pattern, value) {
+  const regex = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${regex}$`).test(value);
+}
+var GLOB_MATCH_KEYS = /* @__PURE__ */ new Set(["channel", "sender"]);
+var NON_MATCH_KEYS = /* @__PURE__ */ new Set(["session", "destination", "path", "mode"]);
+function ruleMatches(rule, meta) {
+  for (const [key, pattern] of Object.entries(rule)) {
+    if (NON_MATCH_KEYS.has(key)) continue;
+    if (key === "isDM") {
+      if (typeof pattern !== "boolean") return false;
+      if ((meta.isDM ?? false) !== pattern) return false;
+      continue;
+    }
+    if (key === "participants") {
+      if (typeof pattern !== "number") return false;
+      if ((meta.participantCount ?? 0) !== pattern) return false;
+      continue;
+    }
+    if (typeof pattern !== "string") return false;
+    if (!GLOB_MATCH_KEYS.has(key)) return false;
+    const value = meta[key] ?? "";
+    if (!globMatch(pattern, value)) return false;
+  }
+  return true;
+}
+function expandTemplate(template, meta) {
+  return template.replace(/\$\{sender\}/g, meta.sender ?? "unknown").replace(/\$\{channel\}/g, meta.channel ?? "unknown");
+}
+function sanitizeSessionName(name) {
+  return name.replace(/\0/g, "").replace(/[/\\]/g, "-").replace(/\.\./g, "-").slice(0, 100);
+}
+function resolveRoute(config, meta) {
+  const fallback = config.default ?? "main";
+  if (!config.rules) {
+    return { destination: "mind", session: fallback, matched: false };
+  }
+  for (const rule of config.rules) {
+    if (ruleMatches(rule, meta)) {
+      if (rule.destination === "file") {
+        if (!rule.path) {
+          dlog.warn("file destination rule missing path \u2014 falling through");
+          continue;
+        }
+        return { destination: "file", path: rule.path, matched: true };
+      }
+      return {
+        destination: "mind",
+        session: sanitizeSessionName(expandTemplate(rule.session ?? fallback, meta)),
+        matched: true,
+        mode: rule.mode
+      };
+    }
+  }
+  return { destination: "mind", session: fallback, matched: false };
+}
+var DEFAULT_BATCH_DEBOUNCE = 5;
+var DEFAULT_BATCH_MAX_WAIT = 120;
+function normalizeBatchConfig(batch) {
+  if (typeof batch === "number") return { maxWait: batch * 60 };
+  return batch;
+}
+function resolveDeliveryMode(config, sessionName) {
+  const defaults = {
+    delivery: { mode: "immediate" },
+    interrupt: true
+  };
+  if (!config.sessions) return defaults;
+  for (const [pattern, sessionConfig] of Object.entries(config.sessions)) {
+    if (globMatch(pattern, sessionName)) {
+      let delivery;
+      if (sessionConfig.delivery != null) {
+        if (sessionConfig.delivery === "immediate") {
+          delivery = { mode: "immediate" };
+        } else if (sessionConfig.delivery === "batch") {
+          delivery = {
+            mode: "batch",
+            debounce: DEFAULT_BATCH_DEBOUNCE,
+            maxWait: DEFAULT_BATCH_MAX_WAIT
+          };
+        } else {
+          delivery = {
+            mode: "batch",
+            debounce: sessionConfig.delivery.debounce ?? DEFAULT_BATCH_DEBOUNCE,
+            maxWait: sessionConfig.delivery.maxWait ?? DEFAULT_BATCH_MAX_WAIT
+          };
+        }
+      } else if (sessionConfig.batch != null) {
+        const batch = normalizeBatchConfig(sessionConfig.batch);
+        delivery = {
+          mode: "batch",
+          debounce: batch.debounce ?? DEFAULT_BATCH_DEBOUNCE,
+          maxWait: batch.maxWait ?? DEFAULT_BATCH_MAX_WAIT,
+          triggers: batch.triggers
+        };
+      } else if (sessionConfig.interrupt === false) {
+        delivery = {
+          mode: "batch",
+          debounce: DEFAULT_BATCH_DEBOUNCE,
+          maxWait: DEFAULT_BATCH_MAX_WAIT
+        };
+      } else {
+        delivery = { mode: "immediate" };
+      }
+      return {
+        delivery,
+        interrupt: sessionConfig.interrupt ?? true,
+        instructions: sessionConfig.instructions
+      };
+    }
+  }
+  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");
+var MAX_BATCH_SIZE = 50;
+var DeliveryManager = class {
+  sessionStates = /* @__PURE__ */ new Map();
+  batchBuffers = /* @__PURE__ */ new Map();
+  // --- 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] = mindName.split("@", 2);
+    const config = getRoutingConfig(baseName);
+    const meta = {
+      channel: payload.channel,
+      sender: payload.sender ?? void 0,
+      isDM: payload.isDM,
+      participantCount: payload.participantCount
+    };
+    const route = resolveRoute(config, meta);
+    if (route.destination === "file") {
+      return { routed: true, session: route.path, destination: "file", mode: "immediate" };
+    }
+    if (!route.matched && config.gateUnmatched !== false) {
+      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);
+      const escaped = baseName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const pattern = new RegExp(`\\b${escaped}\\b`, "i");
+      if (!pattern.test(text)) {
+        return { routed: false, reason: "mention-filtered" };
+      }
+    }
+    let sessionName = route.session;
+    if (sessionName === "$new") {
+      sessionName = `new-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    }
+    const sessionConfig = resolveDeliveryMode(config, sessionName);
+    if (sessionConfig.delivery.mode === "batch") {
+      this.enqueueBatch(mindName, sessionName, payload, sessionConfig);
+      return { routed: true, session: sessionName, destination: "mind", mode: "batch" };
+    }
+    await this.deliverToMind(mindName, sessionName, payload, sessionConfig);
+    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.
+   */
+  sessionDone(mindName, session) {
+    const [baseName] = mindName.split("@", 2);
+    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.
+   */
+  async restoreFromDb() {
+    try {
+      const db = await getDb();
+      const rows = await db.select().from(deliveryQueue).where(eq(deliveryQueue.status, "pending"));
+      for (const row of rows) {
+        let payload;
+        try {
+          payload = JSON.parse(row.payload);
+        } catch (parseErr) {
+          dlog3.warn(
+            `corrupt payload in delivery queue row ${row.id}, skipping`,
+            logger_default.errorData(parseErr)
+          );
+          continue;
+        }
+        const config = getRoutingConfig(row.mind);
+        const sessionConfig = resolveDeliveryMode(config, row.session);
+        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));
+          });
+        }
+      }
+      if (rows.length > 0) {
+        dlog3.info(`restored ${rows.length} queued messages from DB`);
+      }
+    } catch (err) {
+      dlog3.warn("failed to restore delivery queue from DB", 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(and(eq(deliveryQueue.mind, mindName), eq(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 state = this.sessionStates.get(mindName)?.get(session);
+    return (state?.activeCount ?? 0) > 0;
+  }
+  /**
+   * 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();
+    if (instance2 === this) instance2 = void 0;
+  }
+  // --- Private ---
+  async deliverToMind(mindName, session, payload, sessionConfig) {
+    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 (variantName) {
+      const variant = findVariant(baseName, variantName);
+      if (!variant) {
+        dlog3.warn(`cannot deliver to ${mindName}: variant not found`);
+        return;
+      }
+      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);
+    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} responded ${res.status}: ${text}`);
+        this.decrementActive(baseName, session);
+        if (payload.channel) typingMap.delete(payload.channel, baseName);
+      } else {
+        await res.text().catch(() => {
+        });
+      }
+    } 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);
+    } 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`);
+      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;
+      }
+      port = variant.port;
+    }
+    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 typingMap = getTypingMap();
+    for (const ch of Object.keys(channels)) {
+      if (ch !== "unknown") typingMap.set(ch, baseName, { persistent: true });
+    }
+    const batchBody = {
+      session,
+      batch: { channels },
+      interrupt: 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}`);
+        this.decrementActive(baseName, session);
+        for (const ch of Object.keys(channels)) {
+          typingMap.delete(ch, baseName);
+        }
+      } else {
+        await res.text().catch(() => {
+        });
+        try {
+          const db = await getDb();
+          await db.delete(deliveryQueue).where(
+            and(
+              eq(deliveryQueue.mind, baseName),
+              eq(deliveryQueue.session, session),
+              eq(deliveryQueue.status, "pending")
+            )
+          );
+        } catch (err) {
+          dlog3.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));
+      this.decrementActive(baseName, session);
+      for (const ch of Object.keys(channels)) {
+        typingMap.delete(ch, baseName);
+      }
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  enqueueBatch(mindName, session, payload, sessionConfig) {
+    const delivery = sessionConfig.delivery;
+    if (delivery.triggers?.length) {
+      const text = extractTextContent(payload.content);
+      const lower = text.toLowerCase();
+      if (delivery.triggers.some((t) => lower.includes(t.toLowerCase()))) {
+        this.flushBatch(mindName, session, [
+          {
+            payload,
+            channel: payload.channel,
+            sender: payload.sender ?? null,
+            createdAt: Date.now()
+          }
+        ]);
+        return;
+      }
+    }
+    this.persistToQueue(mindName, session, payload).catch((err) => {
+      dlog3.warn(`failed to persist batch message for ${mindName}/${session}`, logger_default.errorData(err));
+    });
+    this.addToBatchBuffer(mindName, session, payload, sessionConfig);
+  }
+  addToBatchBuffer(mindName, session, payload, sessionConfig) {
+    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({
+      payload,
+      channel: payload.channel,
+      sender: payload.sender ?? null,
+      createdAt: Date.now()
+    });
+    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();
+    }
+  }
+  flushBatch(mindName, session, extra) {
+    const bufferKey = `${mindName}:${session}`;
+    const buffer = this.batchBuffers.get(bufferKey);
+    const messages = [];
+    if (buffer) {
+      if (buffer.debounceTimer) clearTimeout(buffer.debounceTimer);
+      if (buffer.maxWaitTimer) clearTimeout(buffer.maxWaitTimer);
+      buffer.debounceTimer = null;
+      buffer.maxWaitTimer = null;
+      messages.push(...buffer.messages.splice(0));
+      this.batchBuffers.delete(bufferKey);
+    }
+    if (extra) messages.push(...extra);
+    if (messages.length === 0) return;
+    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));
+    });
+  }
+  async gateMessage(mindName, session, payload) {
+    const [baseName] = mindName.split("@", 2);
+    await this.persistToQueue(baseName, session, payload, "gated");
+    try {
+      const db = await getDb();
+      const count = await db.select({ count: sql`count(*)` }).from(deliveryQueue).where(
+        and(
+          eq(deliveryQueue.mind, baseName),
+          eq(deliveryQueue.channel, payload.channel),
+          eq(deliveryQueue.status, "gated")
+        )
+      );
+      if ((count[0]?.count ?? 0) <= 1) {
+        await this.sendInviteNotification(mindName, payload);
+      }
+    } catch (err) {
+      dlog3.warn(`failed to check gated count for ${baseName}`, logger_default.errorData(err));
+    }
+  }
+  async sendInviteNotification(mindName, payload) {
+    const text = extractTextContent(payload.content);
+    const preview = text.length > 200 ? `${text.slice(0, 200)}...` : text;
+    const channel = payload.channel ?? "unknown";
+    const notification = [
+      `[New channel: ${channel}]`,
+      `Sender: ${payload.sender ?? "unknown"}`,
+      payload.platform ? `Platform: ${payload.platform}` : null,
+      payload.participantCount ? `Participants: ${payload.participantCount}` : null,
+      "",
+      `Preview: ${preview}`,
+      "",
+      `To accept this channel, add a routing rule for "${channel}" to your routes.json.`,
+      `Messages are being held until a route is configured.`
+    ].filter((line) => line !== null).join("\n");
+    const invitePayload = {
+      channel: "system:delivery",
+      sender: "system",
+      content: [{ type: "text", text: notification }]
+    };
+    const config = getRoutingConfig(mindName.split("@", 2)[0]);
+    const sessionConfig = resolveDeliveryMode(config, "main");
+    await this.deliverToMind(mindName, "main", invitePayload, {
+      ...sessionConfig,
+      interrupt: true
+    });
+  }
+  async persistToQueue(mindName, session, payload, status = "pending") {
+    try {
+      const db = await getDb();
+      await db.insert(deliveryQueue).values({
+        mind: mindName,
+        session,
+        channel: payload.channel ?? null,
+        sender: payload.sender ?? null,
+        status,
+        payload: JSON.stringify(payload)
+      });
+    } catch (err) {
+      dlog3.warn(
+        `failed to persist to delivery queue for ${mindName}/${session}`,
+        logger_default.errorData(err)
+      );
+    }
+  }
+  incrementActive(mind, session) {
+    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 };
+    state.activeCount++;
+    state.lastDeliveredAt = Date.now();
+    mindSessions.set(session, state);
+  }
+  decrementActive(mind, session) {
+    const mindSessions = this.sessionStates.get(mind);
+    if (!mindSessions) return;
+    const state = mindSessions.get(session);
+    if (!state) return;
+    state.activeCount = Math.max(0, state.activeCount - 1);
+    if (state.activeCount === 0) {
+      const bufferKey = `${mind}:${session}`;
+      const buffer = this.batchBuffers.get(bufferKey);
+      if (buffer && buffer.messages.length > 0) {
+        this.scheduleBatchTimers(mind, session, bufferKey);
+      }
+    }
+  }
+};
+var instance2;
+function initDeliveryManager() {
+  if (instance2) return instance2;
+  instance2 = new DeliveryManager();
+  return instance2;
+}
+function getDeliveryManager() {
+  if (!instance2) {
+    throw new Error("DeliveryManager not initialized \u2014 call initDeliveryManager() first");
+  }
+  return instance2;
+}
+
+export {
+  extractTextContent,
+  deliverMessage,
+  getTypingMap,
+  DeliveryManager,
+  initDeliveryManager,
+  getDeliveryManager
+};