volute 0.53.0 → 0.55.0

package/dist/{chunk-RQRO6PC7.js → chunk-TMTAHKYP.js}

@@ -1,41 +1,43 @@
 #!/usr/bin/env node
 import {
   tryGetMindManager
-} from "./chunk-23UJGVYP.js";
-import {
-  extractTextContent,
-  getRoutingConfig,
-  resolveDeliveryMode,
-  resolveRoute,
-  setRoutesChangeListener,
-  shouldGate
-} from "./chunk-UDZLPR34.js";
+} from "./chunk-HLWQ3P3R.js";
 import {
   linkInboundToActiveTurn
-} from "./chunk-VDZ4I4ZP.js";
-import {
-  MIND_LEVEL_THREAD,
-  newEphemeralSession
-} from "./chunk-IQ7VNWH6.js";
-import {
-  publish
-} from "./chunk-LNNI3MS4.js";
+} from "./chunk-BP2X5AIK.js";
 import {
   getParticipants,
   publish as publish2
-} from "./chunk-TPX6E6PL.js";
+} from "./chunk-6HBGUPBA.js";
 import {
   onMindEvent
-} from "./chunk-UFTDRTCP.js";
+} from "./chunk-7AA4T2RT.js";
 import {
   renderAvatarBlock
-} from "./chunk-ICXY54ZC.js";
+} from "./chunk-IT4GEFDH.js";
 import {
   readVoluteConfig
 } from "./chunk-WCFSBH33.js";
+import {
+  clearConfigCache,
+  extractTextContent,
+  getRoutingConfig,
+  resolveDeliveryMode,
+  resolveRoute,
+  routesConfigPath,
+  setRoutesChangeListener,
+  shouldGate
+} from "./chunk-W3OIPJPB.js";
+import {
+  MIND_LEVEL_THREAD,
+  newEphemeralSession
+} from "./chunk-DUV4EMNW.js";
+import {
+  publish
+} from "./chunk-MNKPAAQF.js";
 import {
   logger_default
-} from "./chunk-QUSMYGNQ.js";
+} from "./chunk-2674KIGI.js";
 import {
   slugify
 } from "./chunk-LGNUFVMR.js";
@@ -48,14 +50,15 @@ import {
 } from "./chunk-H6X6CKDN.js";
 import {
   channelGates,
+  channels,
   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 { mkdir, readFile, realpath, rename, writeFile } from "fs/promises";
+import { dirname, resolve } from "path";
 import { and as and2, eq as eq2, inArray, sql } from "drizzle-orm";
 
 // packages/daemon/src/lib/chat/typing.ts
@@ -141,8 +144,8 @@ function getTypingMap() {
 function isConversationId(channel) {
   return !channel.startsWith("@") && !channel.startsWith("#") && !channel.includes(":") && !channel.includes("/");
 }
-function publishTypingForChannels(channels, map) {
-  for (const channel of channels) {
+function publishTypingForChannels(channels2, map) {
+  for (const channel of channels2) {
     if (isConversationId(channel)) {
       publish2(channel, { type: "typing", senders: map.get(channel) });
     }
@@ -217,6 +220,27 @@ function formatHoldNotice(channelLabel, unseen) {
 // packages/daemon/src/lib/delivery/delivery-manager.ts
 var dlog = logger_default.child("delivery-manager");
 var MAX_BATCH_SIZE = 50;
+function normalizeChannelKey(channel) {
+  return channel.replace(/^[#@]/, "").toLowerCase();
+}
+function formatSuggestions(suggestions) {
+  const quoted = suggestions.map((s) => `"${s}"`);
+  if (quoted.length <= 1) return quoted.join("");
+  if (quoted.length === 2) return `${quoted[0]} or ${quoted[1]}`;
+  return `${quoted.slice(0, -1).join(", ")}, or ${quoted[quoted.length - 1]}`;
+}
+var UnknownChannelError = class extends Error {
+  constructor(channel, suggestions) {
+    super(
+      `no channel named "${channel}" \u2014 did you mean ${formatSuggestions(suggestions)}? (quote it: the shell strips an unquoted #name)`
+    );
+    this.channel = channel;
+    this.suggestions = suggestions;
+    this.name = "UnknownChannelError";
+  }
+  channel;
+  suggestions;
+};
 var REDRIVE_INTERVAL_MS = 15e3;
 var RETRY_BASE_MS = 5e3;
 var RETRY_MAX_MS = 5 * 6e4;
@@ -224,6 +248,7 @@ var REDRIVE_BATCH_LIMIT = 200;
 var MAX_DELIVERY_ATTEMPTS = 10;
 var GATED_RELEASE_LIMIT_PER_CHANNEL = 10;
 var GATED_NOTIFY_EVERY = 10;
+var PEEK_LIMIT = 50;
 var mentionRegexCache = /* @__PURE__ */ new Map();
 var avatarBlocksCache = /* @__PURE__ */ new Map();
 var AVATAR_CACHE_TTL = 5 * 60 * 1e3;
@@ -241,17 +266,28 @@ var DeliveryManager = class {
    * messages to the same session can't be reordered by resolvePort/enrichment latency.
    */
   drainChains = /* @__PURE__ */ new Map();
+  /**
+   * Per-`baseName` promise chain that serializes gated releases. `releaseGated` reads gated
+   * rows and then writes `mind_history`; the promote UPDATE is idempotent but the history
+   * INSERT is not, so two overlapping runs would record the same message twice.
+   */
+  releaseChains = /* @__PURE__ */ new Map();
+  /**
+   * Per-`baseName` promise chain serializing accepts, whose read-modify-write of
+   * routes.json would otherwise lose a rule when two run concurrently.
+   */
+  acceptChains = /* @__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-YTOU66QI.js");
+    const { deliverEvent } = await import("./system-events-ZYOCYAO2.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-YTOU66QI.js");
+    const { recordNotice } = await import("./system-events-ZYOCYAO2.js");
     await recordNotice(input);
   };
   /**
@@ -259,7 +295,7 @@ var DeliveryManager = class {
    * side); no-ops for human senders. Overridable in tests.
    */
   notifySenderFailure = async (sender, channel, reason) => {
-    const { recordSenderDeliveryFailure } = await import("./delivery-notices-65TB3CBX.js");
+    const { recordSenderDeliveryFailure } = await import("./delivery-notices-S7TKOACE.js");
     await recordSenderDeliveryFailure(sender, channel, reason);
   };
   constructor() {
@@ -456,9 +492,27 @@ var DeliveryManager = class {
    *    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.
+   *
+   * Releases are serialized per mind: the promote step reads gated rows and then writes
+   * `mind_history`, and while the promote UPDATE is idempotent the history INSERT is not —
+   * two overlapping runs would both see the same rows and record the message twice.
    */
   async releaseGated(mindName) {
     const baseName = await getBaseName(mindName);
+    const prev = this.releaseChains.get(baseName) ?? Promise.resolve();
+    const run = prev.then(() => this.releaseGatedInner(mindName, baseName));
+    const chain = run.then(
+      () => void 0,
+      () => void 0
+    );
+    this.releaseChains.set(baseName, chain);
+    try {
+      return await run;
+    } finally {
+      if (this.releaseChains.get(baseName) === chain) this.releaseChains.delete(baseName);
+    }
+  }
+  async releaseGatedInner(mindName, baseName) {
     const config = getRoutingConfig(baseName);
     let rows;
     try {
@@ -466,7 +520,7 @@ var DeliveryManager = class {
       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;
+      return { released: 0, archived: 0 };
     }
     const byChannel = /* @__PURE__ */ new Map();
     const archiveIds = [];
@@ -515,7 +569,7 @@ var DeliveryManager = class {
       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}).`
+          `${channel}: released the ${keep.length} most recent message(s); ${drop.length} earlier message(s) were held while unrouted and stay readable (volute chat channels peek "${channel}").`
         );
         dlog.info(
           `truncated gated release for ${baseName} on ${channel}: kept ${keep.length}, archived ${drop.length}`
@@ -534,9 +588,10 @@ var DeliveryManager = class {
     }
     if (promote.length === 0) {
       if (truncationNotes.length > 0) await this.sendReleaseSummary(mindName, truncationNotes);
-      return;
+      return { released: 0, archived: archiveIds.length };
     }
     const orderedPromote = [...promote].sort((a, b) => a.id - b.id);
+    let committed = 0;
     try {
       const db = await getDb();
       for (const p of orderedPromote) {
@@ -550,14 +605,15 @@ var DeliveryManager = class {
           });
           await tx.update(deliveryQueue).set({ status: "pending", thread: p.session, attempts: 0, next_attempt_at: null }).where(eq2(deliveryQueue.id, p.id));
         });
+        committed++;
       }
-      dlog.info(`released ${promote.length} gated message(s) for ${baseName} after route change`);
+      dlog.info(`released ${committed} 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;
+      return { released: committed, archived: archiveIds.length };
     }
     for (const p of orderedPromote) {
       publish(baseName, {
@@ -570,6 +626,63 @@ var DeliveryManager = class {
     }
     if (truncationNotes.length > 0) await this.sendReleaseSummary(mindName, truncationNotes);
     await this.redrive();
+    return { released: committed, archived: archiveIds.length };
+  }
+  /**
+   * Channels this mind could plausibly mean, from three sources:
+   *
+   * 1. Its current queue rows — channels with a live `gated`/`archived`/`pending` backlog.
+   * 2. Its own history — the durable record. Source 1 alone is not enough: delivered rows
+   *    are *deleted* (`deleteQueueRows`), so a channel the mind has been using
+   *    successfully for months drops out of the queue entirely, and an external-platform
+   *    channel like `discord:general` is in no other table. Without this, the healthier
+   *    the channel, the more likely we'd call it unrecognized.
+   * 3. Every *public* Volute channel, so a channel can be recognized before its first
+   *    message ever arrives.
+   *
+   * Private channels are deliberately excluded from source 3. This set feeds the "did you
+   * mean X?" suggestion, so anything in it can be echoed back to a mind that guessed a
+   * nearby name — which would turn a typo into a way to confirm a private channel exists
+   * and learn its exact slug. Minds are untrusted principals. A private channel the mind
+   * is genuinely in still resolves via sources 1 and 2, which are scoped to it.
+   */
+  async knownChannels(baseName) {
+    const db = await getDb();
+    const queued = await db.selectDistinct({ channel: deliveryQueue.channel }).from(deliveryQueue).where(eq2(deliveryQueue.mind, baseName));
+    const seen = await db.selectDistinct({ channel: mindHistory.channel }).from(mindHistory).where(eq2(mindHistory.mind, baseName));
+    const named = await db.selectDistinct({ name: channels.name }).from(channels).where(eq2(channels.private, 0));
+    const out = /* @__PURE__ */ new Set();
+    for (const r of queued) if (r.channel) out.add(r.channel);
+    for (const r of seen) if (r.channel) out.add(r.channel);
+    for (const r of named) out.add(`#${r.name}`);
+    return [...out];
+  }
+  /**
+   * Match a channel name the caller supplied against the channels that actually exist.
+   *
+   * The failure this exists to prevent: a mind is told to run `... accept #garden`, hits
+   * the shell's comment character, drops the `#` to "fix" it, and accepts `garden` — a
+   * name nothing will ever send from. That wrote a permanent junk rule to routes.json and
+   * reported success, leaving the mind believing it had joined a channel it could send to
+   * but would never hear from. A one-way channel it had no reason to doubt.
+   *
+   * A near-miss (same name modulo sigil and case) is reported so callers can refuse with
+   * the real slug. A name with no near-miss is *not* an error — pre-routing a channel
+   * before its first message arrives is legitimate — but it comes back `known: false` so
+   * callers can say plainly that nothing was recognized instead of implying a join.
+   */
+  async matchChannelName(baseName, channel) {
+    let all;
+    try {
+      all = await this.knownChannels(baseName);
+    } catch (err) {
+      dlog.warn(`failed to list known channels for ${baseName}`, logger_default.errorData(err));
+      return { known: true, suggestions: [] };
+    }
+    if (all.includes(channel)) return { known: true, suggestions: [] };
+    const key = normalizeChannelKey(channel);
+    const near = all.filter((c) => normalizeChannelKey(c) === key).sort();
+    return { known: false, suggestions: near };
   }
   /**
    * Whether the mind has explicitly declined a channel. A declined channel keeps
@@ -593,6 +706,8 @@ var DeliveryManager = class {
    */
   async declineChannel(mindName, channel) {
     const baseName = await getBaseName(mindName);
+    const match = await this.matchChannelName(baseName, channel);
+    if (match.suggestions.length > 0) throw new UnknownChannelError(channel, match.suggestions);
     const db = await getDb();
     await db.insert(channelGates).values({ mind: baseName, channel, state: "declined" }).onConflictDoUpdate({
       target: [channelGates.mind, channelGates.channel],
@@ -610,6 +725,163 @@ var DeliveryManager = class {
     );
     return archived.length;
   }
+  /**
+   * Accept an unrouted (gated) channel: add a routing rule for it to the mind's routes.json
+   * and release its held messages immediately.
+   *
+   * This exists because a hand-edited routes.json is only noticed lazily, when the *next*
+   * inbound message triggers a config read — so editing the file on a quiet mind releases
+   * nothing and the held messages sit there indefinitely. Accept applies the change and
+   * reports what it actually released. #537
+   */
+  async acceptChannel(mindName, channel, thread) {
+    const baseName = await getBaseName(mindName);
+    const prev = this.acceptChains.get(baseName) ?? Promise.resolve();
+    const run = prev.then(() => this.acceptChannelInner(mindName, baseName, channel, thread));
+    const chain = run.then(
+      () => void 0,
+      () => void 0
+    );
+    this.acceptChains.set(baseName, chain);
+    try {
+      return await run;
+    } finally {
+      if (this.acceptChains.get(baseName) === chain) this.acceptChains.delete(baseName);
+    }
+  }
+  async acceptChannelInner(mindName, baseName, channel, thread) {
+    const match = await this.matchChannelName(baseName, channel);
+    if (match.suggestions.length > 0) throw new UnknownChannelError(channel, match.suggestions);
+    const path = routesConfigPath(baseName);
+    let config;
+    try {
+      const parsed = JSON.parse(await readFile(path, "utf-8"));
+      if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`routes.json for ${baseName} is malformed (not a JSON object)`);
+      }
+      config = parsed;
+    } catch (err) {
+      if (err?.code !== "ENOENT") {
+        throw new Error(
+          `routes.json for ${baseName} is unreadable or malformed \u2014 not modifying it`
+        );
+      }
+      config = {};
+    }
+    const rules = Array.isArray(config.rules) ? config.rules : [];
+    const targetThread = thread ?? "${channel}";
+    const existing = resolveRoute({ ...config, rules }, { channel });
+    const ruleAdded = !existing.matched;
+    if (ruleAdded) {
+      rules.push({ channel, thread: targetThread });
+      config.rules = rules;
+      await mkdir(dirname(path), { recursive: true });
+      const tmp = `${path}.${process.pid}.tmp`;
+      await writeFile(tmp, `${JSON.stringify(config, null, 2)}
+`);
+      await rename(tmp, path);
+    }
+    const db = await getDb();
+    await db.delete(channelGates).where(and2(eq2(channelGates.mind, baseName), eq2(channelGates.channel, channel)));
+    const heldBefore = await db.select({ id: deliveryQueue.id }).from(deliveryQueue).where(
+      and2(
+        eq2(deliveryQueue.mind, baseName),
+        eq2(deliveryQueue.channel, channel),
+        eq2(deliveryQueue.status, "gated")
+      )
+    );
+    clearConfigCache(baseName, { notify: false });
+    await this.releaseGated(mindName);
+    let released = 0;
+    let archived = 0;
+    const ids = heldBefore.map((r) => r.id);
+    for (let i = 0; i < ids.length; i += 500) {
+      const after = await db.select({ status: deliveryQueue.status }).from(deliveryQueue).where(inArray(deliveryQueue.id, ids.slice(i, i + 500)));
+      for (const row of after) {
+        if (row.status === "archived") archived++;
+        else if (row.status !== "gated") released++;
+      }
+    }
+    dlog.info(
+      `accepted channel ${channel} for ${baseName} (rule ${ruleAdded ? "added" : "already present"}); released ${released}, archived ${archived}`
+    );
+    const finalRoute = ruleAdded ? resolveRoute({ ...config, rules }, { channel }) : existing;
+    return {
+      ruleAdded,
+      thread: finalRoute.destination === "file" ? finalRoute.path : finalRoute.session,
+      released,
+      archived,
+      known: match.known
+    };
+  }
+  /**
+   * Read the messages held on a channel without changing anything. Archived rows are
+   * included: a truncated or declined backlog stays readable, which is what the invite and
+   * release-summary texts promise. Gated messages have no conversation, so `volute chat
+   * read` can't show them — this is the only way to see them.
+   *
+   * Returns the most recent {@link PEEK_LIMIT} messages (oldest-first within that window)
+   * alongside the true total, so peeking at a spam channel with a huge backlog can't dump
+   * all of it into the mind's context — the same reason releases are truncated. #537
+   */
+  async peekChannel(mindName, channel) {
+    const baseName = await getBaseName(mindName);
+    const db = await getDb();
+    const rows = await db.select().from(deliveryQueue).where(
+      and2(
+        eq2(deliveryQueue.mind, baseName),
+        eq2(deliveryQueue.channel, channel),
+        inArray(deliveryQueue.status, ["gated", "archived"])
+      )
+    );
+    const messages2 = rows.sort((a, b) => a.id - b.id).slice(-PEEK_LIMIT).map((row) => {
+      let content = "";
+      try {
+        content = extractTextContent(JSON.parse(row.payload).content);
+      } catch {
+        content = "(unreadable payload)";
+      }
+      return {
+        sender: row.sender,
+        content,
+        createdAt: row.created_at,
+        status: row.status
+      };
+    });
+    const near = rows.length === 0 ? (await this.matchChannelName(baseName, channel)).suggestions : [];
+    return {
+      channel,
+      count: rows.length,
+      shown: messages2.length,
+      suggestions: near.length > 0 ? near : void 0,
+      messages: messages2
+    };
+  }
+  /**
+   * Re-evaluate every mind's held messages against its current routes.json. Run at daemon
+   * startup: routes.json edits made while the daemon was down would otherwise not be noticed
+   * until the next inbound message on that channel — which, for a quiet channel, may be never.
+   */
+  async releaseGatedSweep() {
+    let minds;
+    try {
+      const db = await getDb();
+      minds = await db.selectDistinct({ mind: deliveryQueue.mind }).from(deliveryQueue).where(eq2(deliveryQueue.status, "gated"));
+    } catch (err) {
+      dlog.warn("failed to list minds with gated messages", logger_default.errorData(err));
+      return;
+    }
+    for (const { mind } of minds) {
+      try {
+        const { released, archived } = await this.releaseGated(mind);
+        if (released > 0 || archived > 0) {
+          dlog.info(`startup sweep for ${mind}: released ${released}, archived ${archived}`);
+        }
+      } catch (err) {
+        dlog.warn(`startup gated sweep failed for ${mind}`, logger_default.errorData(err));
+      }
+    }
+  }
   /**
    * Send the mind a single summary when a routing change released a truncated backlog,
    * rather than a flood of individual messages. #537
@@ -872,8 +1144,8 @@ var DeliveryManager = class {
       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 channels2 = [...new Set(rows.map((r) => r.channel).filter((c) => !!c))];
+    const recovery = channels2.length > 0 ? `The original message(s) remain in the channel history \u2014 read them with ${channels2.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,
@@ -922,9 +1194,9 @@ ${channel}`, { sender: r.sender, channel });
       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 channels2 = /* @__PURE__ */ new Set();
+      if (payload.channel) channels2.add(payload.channel);
+      this.incrementActive(baseName, session, senders, channels2);
       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))
@@ -942,7 +1214,8 @@ ${channel}`, { sender: r.sender, channel });
       const body = JSON.stringify({
         ...enrichedPayload,
         session,
-        instructions: sessionConfig.instructions
+        instructions: sessionConfig.instructions,
+        interrupt: sessionConfig.interrupt
       });
       try {
         const ok = await this.postToMind(port, body);
@@ -987,11 +1260,11 @@ ${channel}`, { sender: r.sender, channel });
           return { ...msg, payload: enrichedPayload };
         })
       );
-      const channels = {};
+      const channels2 = {};
       for (const msg of enrichedMessages) {
         const ch = msg.channel ?? "unknown";
-        if (!channels[ch]) channels[ch] = [];
-        channels[ch].push(msg.payload);
+        if (!channels2[ch]) channels2[ch] = [];
+        channels2[ch].push(msg.payload);
       }
       const senders = /* @__PURE__ */ new Set();
       const channelSet = /* @__PURE__ */ new Set();
@@ -1013,7 +1286,7 @@ ${channel}`, { sender: r.sender, channel });
         );
       }
       const typingMap = getTypingMap();
-      for (const ch of Object.keys(channels)) {
+      for (const ch of Object.keys(channels2)) {
         if (ch !== "unknown") typingMap.set(ch, baseName, { persistent: true });
       }
       const seenConvIds = /* @__PURE__ */ new Set();
@@ -1028,8 +1301,9 @@ ${channel}`, { sender: r.sender, channel });
       }
       const body = JSON.stringify({
         session,
-        batch: { channels },
-        instructions: sessionConfig.instructions
+        batch: { channels: channels2 },
+        instructions: sessionConfig.instructions,
+        interrupt: sessionConfig.interrupt
       });
       try {
         const ok = await this.postToMind(port, body);
@@ -1164,7 +1438,7 @@ ${channel}`, { sender: r.sender, channel });
     const details = detailLines.length > 0 ? `${detailLines.join("\n")}
 
 ` : "\n";
-    const { getPrompt } = await import("./prompts-HNKGCAEY.js");
+    const { getPrompt } = await import("./prompts-MOBF3TMO.js");
     const notification = await getPrompt("channel_invite", {
       channel,
       heldLine,
@@ -1284,7 +1558,7 @@ ${channel}`, { sender: r.sender, channel });
     avatarBlocksCache.set(cacheKey, { blocks, expiresAt: now + AVATAR_CACHE_TTL });
     return blocks;
   }
-  incrementActive(mind, session, senders, channels) {
+  incrementActive(mind, session, senders, channels2) {
     let mindSessions = this.sessionStates.get(mind);
     if (!mindSessions) {
       mindSessions = /* @__PURE__ */ new Map();
@@ -1300,7 +1574,7 @@ ${channel}`, { sender: r.sender, channel });
     state2.activeCount++;
     state2.lastDeliveredAt = Date.now();
     if (senders) state2.lastDeliverySenders = senders;
-    if (channels) state2.lastDeliveryChannels = channels;
+    if (channels2) state2.lastDeliveryChannels = channels2;
     mindSessions.set(session, state2);
   }
   decrementActive(mind, session) {
@@ -1343,6 +1617,8 @@ export {
   publishTypingForChannels,
   checkStaleSend,
   formatHoldNotice,
+  formatSuggestions,
+  UnknownChannelError,
   MAX_DELIVERY_ATTEMPTS,
   DeliveryManager,
   initDeliveryManager,