volute 0.46.0 → 0.47.0

package/dist/{chunk-JO5IO4FH.js → chunk-F55GRIEK.js}

@@ -1,16 +1,25 @@
 #!/usr/bin/env node
 import {
   loadMergedEnv
-} from "./chunk-ZDZISKCL.js";
+} from "./chunk-IYG4FBMP.js";
 import {
   spiritDir
-} from "./chunk-BJZ4PV7R.js";
+} from "./chunk-M6TTZRGH.js";
+import {
+  clearMind,
+  linkInboundToActiveTurn,
+  publish as publish3,
+  summarizeOrphanedTurns
+} from "./chunk-K23P5Q5N.js";
+import {
+  getPrompt
+} from "./chunk-JCMGDCGX.js";
 import {
   hashSkillDir,
   importSkillFromDir,
   removeSharedSkill,
   sharedSkillsDir
-} from "./chunk-KGIXX4NM.js";
+} from "./chunk-IWJSNMSY.js";
 import {
   addMessage,
   createChannel,
@@ -20,63 +29,57 @@ import {
   getParticipants,
   joinChannel,
   publish as publish2
-} from "./chunk-5ZQZDDIK.js";
-import {
-  readVoluteConfig,
-  resolveWakeTriggers,
-  writeVoluteConfig
-} from "./chunk-PFZBNKUH.js";
+} from "./chunk-HPGN6XRT.js";
 import {
   isSandboxEnabled,
   wrapForSandbox
-} from "./chunk-JZ62SYWR.js";
+} from "./chunk-M3XDVS5Q.js";
 import {
   markIdle,
   onMindEvent
-} from "./chunk-KQSFTPIM.js";
+} from "./chunk-MTRMQFCQ.js";
+import {
+  renderAvatarBlock
+} from "./chunk-VMCZBXF2.js";
+import {
+  readVoluteConfig,
+  resolveWakeTriggers,
+  writeVoluteConfig
+} from "./chunk-PFZBNKUH.js";
 import {
   extractTextContent,
   getRoutingConfig,
   resolveDeliveryMode,
   resolveRoute,
   setRoutesChangeListener
-} from "./chunk-4JOQZPCE.js";
-import {
-  clearMind,
-  linkInboundToActiveTurn,
-  publish as publish3,
-  summarizeOrphanedTurns
-} from "./chunk-YXSUMLTC.js";
-import {
-  getPrompt
-} from "./chunk-4YU7HF4L.js";
+} from "./chunk-EIQDZC43.js";
 import {
   chownMindDir,
   exec,
   isIsolationEnabled,
   mindUserName,
   wrapForIsolation
-} from "./chunk-H2X54EHC.js";
+} from "./chunk-DGGZVZTM.js";
 import {
   aiCompleteUtility,
   getAiConfig,
   resolveApiKey
-} from "./chunk-IHKGWTGT.js";
+} from "./chunk-LWDTP6DH.js";
 import {
   readGlobalConfig,
   writeGlobalConfig
-} from "./chunk-F7H6ATM4.js";
+} from "./chunk-SKNXMUIU.js";
 import {
   getOrCreateMindUser,
   getOrCreateSystemUser,
   getUser,
   getUserByUsername,
   syncMindProfile
-} from "./chunk-OV7ZQ2GH.js";
+} from "./chunk-ODDGGLM6.js";
 import {
   publish,
   subscribe
-} from "./chunk-ZNMCCHCP.js";
+} from "./chunk-LTLFOSA4.js";
 import {
   logger_default
 } from "./chunk-T2TP6ZC6.js";
@@ -92,15 +95,16 @@ import {
   stateDir,
   voluteHome,
   voluteSystemDir
-} from "./chunk-ALKYQULU.js";
+} from "./chunk-WW6C3PLV.js";
 import {
   activity,
+  channelGates,
   deliveryQueue,
   messages,
   mindHistory,
   mindNotices,
   sessions
-} from "./chunk-ZV7MFISX.js";
+} from "./chunk-2MJ7EOMT.js";
 
 // packages/daemon/src/lib/delivery/message-delivery.ts
 import { and as and5, eq as eq6, inArray as inArray3 } from "drizzle-orm";
@@ -934,7 +938,7 @@ var MindManager = class {
       if (this.shuttingDown || this.stopping.has(name)) return;
       mlog.error(`mind ${name} exited with code ${code}`);
       try {
-        const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G6TXSDP7.js");
+        const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-3NA7ZJP3.js");
         const sleepMgr = getSleepManagerIfReady2();
         const sleepState = sleepMgr?.getState(name);
         if (sleepState?.sleeping) {
@@ -964,15 +968,15 @@ var MindManager = class {
         (err) => mlog.warn(`failed to clear turn state for ${name} after crash`, logger_default.errorData(err))
       );
       try {
-        const { getDeliveryManager: getDeliveryManager2 } = await import("./delivery-manager-JINZRG2W.js");
+        const { getDeliveryManager: getDeliveryManager2 } = await import("./delivery-manager-TN5KK2AP.js");
         getDeliveryManager2().clearMindSessions(name);
       } catch (err) {
         if (!(err instanceof Error && err.message.includes("not initialized"))) {
           mlog.warn(`failed to clear delivery state for ${name} after crash`, logger_default.errorData(err));
         }
       }
-      import("./mind-activity-tracker-3QRNJVR4.js").then(({ markIdle: markIdle2 }) => markIdle2(name)).catch((err) => mlog.warn(`failed to mark ${name} idle after crash`, logger_default.errorData(err)));
-      import("./activity-events-NF6VWTJQ.js").then(
+      import("./mind-activity-tracker-YVZPC4A5.js").then(({ markIdle: markIdle2 }) => markIdle2(name)).catch((err) => mlog.warn(`failed to mark ${name} idle after crash`, logger_default.errorData(err)));
+      import("./activity-events-MIOK3IOU.js").then(
         ({ publish: publish4 }) => publish4({ type: "mind_stopped", mind: name, summary: `${name} crashed (exit ${code})` })
       ).catch((err) => mlog.warn(`failed to publish crash event for ${name}`, logger_default.errorData(err)));
       const { shouldRestart, delay, attempt } = this.restartTracker.recordCrash(name);
@@ -1030,7 +1034,7 @@ var MindManager = class {
       mlog.warn(`failed to clear turn state for ${name} on stop`, logger_default.errorData(err));
     }
     try {
-      const { getDeliveryManager: getDeliveryManager2 } = await import("./delivery-manager-JINZRG2W.js");
+      const { getDeliveryManager: getDeliveryManager2 } = await import("./delivery-manager-TN5KK2AP.js");
       getDeliveryManager2().clearMindSessions(name);
     } catch (err) {
       if (!(err instanceof Error && err.message.includes("not initialized"))) {
@@ -1038,7 +1042,7 @@ var MindManager = class {
       }
     }
     try {
-      const { clearEchoTextCache } = await import("./echo-text-VQPB5L2X.js");
+      const { clearEchoTextCache } = await import("./echo-text-SEQCLGAT.js");
       clearEchoTextCache(name);
     } catch (err) {
       mlog.debug(`failed to clear echo-text cache for ${name}`, logger_default.errorData(err));
@@ -1362,10 +1366,54 @@ function deleteSystemsConfig() {
   }
 }
 
+// packages/daemon/src/lib/util/sanitize-svg.ts
+import DOMPurify from "isomorphic-dompurify";
+var ALLOWED_TAGS = ["svg", "path", "circle", "rect", "line", "polyline", "polygon", "g"];
+var ALLOWED_ATTR = [
+  "viewBox",
+  "fill",
+  "fill-opacity",
+  "fill-rule",
+  "stroke",
+  "stroke-width",
+  "stroke-linecap",
+  "stroke-linejoin",
+  "stroke-dasharray",
+  "stroke-opacity",
+  "opacity",
+  "d",
+  "cx",
+  "cy",
+  "r",
+  "x",
+  "y",
+  "width",
+  "height",
+  "points",
+  "transform"
+];
+function sanitizeSvgIcon(html) {
+  return DOMPurify.sanitize(html, {
+    ALLOWED_TAGS,
+    ALLOWED_ATTR,
+    FORBID_TAGS: ["script", "foreignObject"],
+    FORBID_ATTR: ["href", "xlink:href"]
+  });
+}
+
 // packages/daemon/src/lib/extensions.ts
 var VALID_EXTENSION_ID = /^[a-z0-9][a-z0-9_-]*$/;
 var loaded = [];
 var discovered = [];
+function enrichActivityMetadata(manifest, metadata) {
+  const enriched = {
+    ...metadata,
+    ...manifest.icon && !metadata?.icon ? { icon: manifest.icon } : {},
+    ...manifest.color && !metadata?.color ? { color: manifest.color } : {}
+  };
+  if (typeof enriched.icon === "string") enriched.icon = sanitizeSvgIcon(enriched.icon);
+  return enriched;
+}
 function toCommandInfo(cmd) {
   const { handler: _, ...info } = cmd;
   return info;
@@ -1469,14 +1517,8 @@ async function buildContext(manifest, dataDir, authMw) {
     getUser: async (id) => getUser(id),
     getUserByUsername: async (username) => getUserByUsername(username),
     publishActivity: (event) => {
-      const enriched = {
-        ...event,
-        metadata: {
-          ...event.metadata,
-          ...manifest.icon && !event.metadata?.icon ? { icon: manifest.icon } : {},
-          ...manifest.color && !event.metadata?.color ? { color: manifest.color } : {}
-        }
-      };
+      const metadata = enrichActivityMetadata(manifest, event.metadata);
+      const enriched = { ...event, metadata };
       publish(enriched).catch(
         (err) => logger_default.error(`extension ${manifest.id}: failed to publish activity`, logger_default.errorData(err))
       );
@@ -1554,14 +1596,8 @@ async function loadExtension(manifest, app, authMw) {
           const result = await cmd.handler(parsed, {
             ...context,
             publishActivity: (rawEvent) => {
-              const event = {
-                ...rawEvent,
-                metadata: {
-                  ...rawEvent.metadata,
-                  ...manifest.icon && !rawEvent.metadata?.icon ? { icon: manifest.icon } : {},
-                  ...manifest.color && !rawEvent.metadata?.color ? { color: manifest.color } : {}
-                }
-              };
+              const metadata = enrichActivityMetadata(manifest, rawEvent.metadata);
+              const event = { ...rawEvent, metadata };
               activityPromises.push(
                 publish(event).catch((err) => {
                   logger_default.error(
@@ -1601,7 +1637,7 @@ async function loadExtension(manifest, app, authMw) {
   }
   if (resolvedAssetsDir && existsSync6(resolvedAssetsDir)) {
     const assetsDir = resolvedAssetsDir;
-    const { readFile: readFile2, stat: fsStat } = await import("fs/promises");
+    const { readFile, stat: fsStat } = await import("fs/promises");
     const { extname: ext } = await import("path");
     const mimeTypes = {
       ".html": "text/html",
@@ -1626,11 +1662,11 @@ async function loadExtension(manifest, app, authMw) {
       const s = await fsStat(filePath).catch(() => null);
       if (s?.isFile()) {
         const mime = mimeTypes[ext(filePath)] || "application/octet-stream";
-        const body = await readFile2(filePath);
+        const body = await readFile(filePath);
         return c.body(body, 200, { "Content-Type": mime });
       }
       if (existsSync6(indexPath)) {
-        const body = await readFile2(indexPath, "utf-8");
+        const body = await readFile(indexPath, "utf-8");
         return c.html(body);
       }
       return c.text("Not found", 404);
@@ -1948,7 +1984,7 @@ async function installNpmExtension(pkg) {
     throw new Error(`Extension "${pkg}" is already installed`);
   }
   const dir = ensureExtensionsNpmDir();
-  const { exec: exec2 } = await import("./exec-G3ZRST4Z.js");
+  const { exec: exec2 } = await import("./exec-QIFYZG4C.js");
   try {
     await exec2("npm", ["install", "--ignore-scripts", pkg], { cwd: dir });
   } catch (err) {
@@ -1969,7 +2005,7 @@ async function uninstallNpmExtension(pkg) {
   packages.splice(idx, 1);
   writeExtensionsConfig(packages);
   try {
-    const { exec: exec2 } = await import("./exec-G3ZRST4Z.js");
+    const { exec: exec2 } = await import("./exec-QIFYZG4C.js");
     await exec2("npm", ["uninstall", "--ignore-scripts", pkg], { cwd: extensionsNpmDir() });
   } catch (err) {
     logger_default.warn(
@@ -2818,7 +2854,7 @@ async function wakeMind(name) {
 async function startSpiritFull(name) {
   const entry = await findMind(name);
   if (entry?.dir) {
-    const { registerMindDir } = await import("./delivery-router-N4A7ZC5T.js");
+    const { registerMindDir } = await import("./delivery-router-3QFG2ZEX.js");
     registerMindDir(name, entry.dir);
   }
   await getMindManager().startMind(name);
@@ -2848,14 +2884,14 @@ function buildSeedOrientation(createdBy, creatorType) {
 async function sendSeedOrientation(mindName, createdBy) {
   let creatorType;
   if (createdBy) {
-    const { getUserByUsername: getUserByUsername2 } = await import("./auth-CCFAU4GQ.js");
+    const { getUserByUsername: getUserByUsername2 } = await import("./auth-A4VGHADI.js");
     creatorType = (await getUserByUsername2(createdBy))?.user_type;
   }
   await sendSystemMessage(mindName, buildSeedOrientation(createdBy, creatorType));
 }
 async function ensureCreatorDM(mindName, creatorUsername) {
-  const { getOrCreateMindUser: getOrCreateMindUser2, getUserByUsername: getUserByUsername2 } = await import("./auth-CCFAU4GQ.js");
-  const { findDMConversation: findDMConversation2, createConversation: createConversation2 } = await import("./conversations-CJOOCGNW.js");
+  const { getOrCreateMindUser: getOrCreateMindUser2, getUserByUsername: getUserByUsername2 } = await import("./auth-A4VGHADI.js");
+  const { findDMConversation: findDMConversation2, createConversation: createConversation2 } = await import("./conversations-C7IKYSHD.js");
   const mindUser = await getOrCreateMindUser2(mindName);
   const creatorUser = await getUserByUsername2(creatorUsername);
   if (!creatorUser) {
@@ -3314,7 +3350,7 @@ var SleepManager = class {
    * the real delivery stack. Returns whether the batch was handed off to the mind.
    */
   async deliverQueuedBatch(name, payloads) {
-    const { deliverBatch: deliverBatch2 } = await import("./message-delivery-R7JSQGYX.js");
+    const { deliverBatch: deliverBatch2 } = await import("./message-delivery-ZE3YGJDD.js");
     return deliverBatch2(name, payloads);
   }
   // --- Wake failure handling (#419) ---
@@ -3709,8 +3745,8 @@ function getSleepManagerIfReady() {
 }
 
 // packages/daemon/src/lib/delivery/delivery-manager.ts
-import { readFile, realpath } from "fs/promises";
-import { extname, resolve as resolve8 } from "path";
+import { realpath } from "fs/promises";
+import { resolve as resolve8 } from "path";
 import { and as and4, eq as eq5, inArray as inArray2, sql as sql2 } from "drizzle-orm";
 
 // packages/daemon/src/lib/chat/typing.ts
@@ -3876,6 +3912,8 @@ var REDRIVE_INTERVAL_MS = 15e3;
 var RETRY_BASE_MS = 5e3;
 var RETRY_MAX_MS = 5 * 6e4;
 var REDRIVE_BATCH_LIMIT = 200;
+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;
@@ -3896,6 +3934,11 @@ var DeliveryManager = class {
   redriveTimer = null;
   /** Predicate for whether a mind is up; overridable in tests. */
   isMindRunning = (name) => tryGetMindManager()?.isRunning(name) ?? false;
+  /** Sends a system message to a mind (invites, release summaries); overridable in tests. */
+  notify = async (mindName, text) => {
+    const { sendSystemMessage: sendSystemMessage2 } = await import("./system-chat-N2F7HVY3.js");
+    await sendSystemMessage2(mindName, text);
+  };
   constructor() {
     setRoutesChangeListener((mind) => {
       this.releaseGated(mind).catch(
@@ -3907,6 +3950,10 @@ var DeliveryManager = class {
   setRunningCheck(fn) {
     this.isMindRunning = fn;
   }
+  /** Test seam: capture/override system notifications sent to minds. */
+  setNotifier(fn) {
+    this.notify = fn;
+  }
   // --- Public API ---
   /**
    * Route and deliver a message to a mind. This is the main entry point.
@@ -4069,9 +4116,15 @@ var DeliveryManager = class {
     if (redriven > 0) dlog.info(`redrove ${redriven} pending delivery queue rows`);
   }
   /**
-   * Re-evaluate a mind's `gated` rows against its current routes.json and promote any
-   * that now match to `pending` (delivered by the next redrive sweep). Called when the
-   * routing config changes.
+   * 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);
@@ -4084,7 +4137,8 @@ var DeliveryManager = class {
       dlog.warn(`failed to read gated rows for ${baseName}`, logger_default.errorData(err));
       return;
     }
-    const promote = [];
+    const byChannel = /* @__PURE__ */ new Map();
+    const archiveIds = [];
     for (const row of rows) {
       let payload;
       try {
@@ -4099,21 +4153,121 @@ var DeliveryManager = class {
         participantCount: payload.participantCount
       };
       const route = resolveRoute(config, meta);
-      if (route.matched && route.destination === "mind") {
-        promote.push(row.id);
+      if (!route.matched) continue;
+      if (route.destination === "file") {
+        archiveIds.push(row.id);
+        continue;
       }
+      let session = route.session;
+      if (session === "$new") {
+        session = `new-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      }
+      const channel = row.channel ?? payload.channel ?? "unknown";
+      const list = byChannel.get(channel) ?? [];
+      list.push({ id: row.id, session });
+      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(inArray2(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;
     }
-    if (promote.length === 0) return;
     try {
       const db = await getDb();
-      await db.update(deliveryQueue).set({ status: "pending", attempts: 0, next_attempt_at: null }).where(inArray2(deliveryQueue.id, promote));
+      for (const p of promote) {
+        await db.update(deliveryQueue).set({ status: "pending", session: p.session, attempts: 0, next_attempt_at: null }).where(eq5(deliveryQueue.id, p.id));
+      }
       dlog.info(`released ${promote.length} gated message(s) for ${baseName} after route change`);
     } catch (err) {
       dlog.warn(`failed to promote gated rows for ${baseName}`, logger_default.errorData(err));
       return;
     }
+    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(and4(eq5(channelGates.mind, baseName), eq5(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: sql2`(datetime('now'))` }
+    });
+    const archived = await db.update(deliveryQueue).set({ status: "archived" }).where(
+      and4(
+        eq5(deliveryQueue.mind, baseName),
+        eq5(deliveryQueue.channel, channel),
+        eq5(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.
    */
@@ -4513,41 +4667,44 @@ var DeliveryManager = class {
   }
   async gateMessage(mindName, session, payload) {
     const baseName = await getBaseName(mindName);
-    await this.persistToQueue(mindName, session, payload, "gated");
+    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 count = await db.select({ count: sql2`count(*)` }).from(deliveryQueue).where(
+      const rows = await db.select({ count: sql2`count(*)` }).from(deliveryQueue).where(
         and4(
           eq5(deliveryQueue.mind, baseName),
           eq5(deliveryQueue.channel, payload.channel),
-          eq5(deliveryQueue.status, "gated")
+          inArray2(deliveryQueue.status, ["gated", "archived"])
         )
       );
-      if ((count[0]?.count ?? 0) <= 1) {
-        await this.sendInviteNotification(mindName, payload);
+      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) {
+  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 notification = [
       `[New channel: ${channel}]`,
-      `Someone new is reaching out \u2014 you don't have a route for this channel yet.`,
+      heldLine,
       `Sender: ${payload.sender ?? "unknown"}`,
       payload.platform ? `Platform: ${payload.platform}` : null,
       payload.participantCount ? `Participants: ${payload.participantCount}` : null,
       "",
       `Preview: ${preview}`,
       "",
-      `To start hearing this channel, add a routing rule for "${channel}" to .config/routes.json.`,
-      `Messages are held safely until you do \u2014 nothing is lost. If you'd rather not engage, just leave it unrouted.`
+      `To start hearing this channel, add a routing rule for "${channel}" to .config/routes.json \u2014 only the ${GATED_RELEASE_LIMIT_PER_CHANNEL} most recent held messages are replayed; older ones stay in the channel history (volute chat read ${channel}).`,
+      `To stop hearing about it, decline the channel: volute chat channels decline ${channel}`
     ].filter((line) => line !== null).join("\n");
-    const { sendSystemMessage: sendSystemMessage2 } = await import("./system-chat-NDAW6YP7.js");
-    await sendSystemMessage2(mindName, notification);
+    await this.notify(mindName, notification);
   }
   /**
    * Insert a delivery_queue row and return its id. The `mind` column is always keyed by
@@ -4612,18 +4769,6 @@ var DeliveryManager = class {
     const cached = avatarBlocksCache.get(cacheKey);
     if (cached && cached.expiresAt > Date.now()) return cached.blocks;
     const blocks = [];
-    let sharpDefault = null;
-    try {
-      const mod = await import("sharp");
-      sharpDefault = mod.default ?? mod;
-    } catch (err) {
-      const code = err.code;
-      if (code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND") {
-        dlog.debug("sharp not available, sending full-size avatars");
-      } else {
-        dlog.warn("sharp import failed, sending full-size avatars", logger_default.errorData(err));
-      }
-    }
     for (const p of participants) {
       if (!p.avatar) continue;
       try {
@@ -4654,32 +4799,8 @@ var DeliveryManager = class {
         } else {
           filePath = resolve8(voluteHome(), "avatars", p.avatar);
         }
-        const ext = extname(filePath).toLowerCase();
-        const mimeMap = {
-          ".png": "image/png",
-          ".jpg": "image/jpeg",
-          ".jpeg": "image/jpeg",
-          ".gif": "image/gif",
-          ".webp": "image/webp"
-        };
-        const mediaType = mimeMap[ext];
-        if (!mediaType) continue;
-        const data = await readFile(filePath);
-        let imageData = data;
-        if (sharpDefault) {
-          try {
-            imageData = await sharpDefault(data).resize(128, 128, { fit: "cover" }).toBuffer();
-          } catch (err) {
-            dlog.warn(
-              `avatar resize failed for ${p.username}, sending original`,
-              logger_default.errorData(err)
-            );
-          }
-        }
-        blocks.push(
-          { type: "text", text: `[Avatar for ${p.username}]` },
-          { type: "image", media_type: mediaType, data: imageData.toString("base64") }
-        );
+        const rendered = await renderAvatarBlock(filePath, p.username);
+        if (rendered) blocks.push(...rendered);
       } catch (err) {
         const code = err.code;
         if (code !== "ENOENT") {
@@ -5007,7 +5128,7 @@ async function spiritWillHandle() {
   const spiritEntry = await findMind(SPIRIT_NAME);
   if (spiritEntry?.running && spiritEntry.mindType === "spirit") return true;
   try {
-    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G6TXSDP7.js");
+    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-3NA7ZJP3.js");
     const sm = getSleepManagerIfReady2();
     if (sm?.isSleeping(SPIRIT_NAME)) return true;
   } catch (err) {
@@ -5035,7 +5156,7 @@ async function generateSystemFallbackReply(conversationId, mindName, message) {
     if (config.sleep.schedule?.wake) contextParts.push(`Wake cron: ${config.sleep.schedule.wake}`);
   }
   try {
-    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G6TXSDP7.js");
+    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-3NA7ZJP3.js");
     const sm = getSleepManagerIfReady2();
     if (sm) {
       const state2 = sm.getState(mindName);
@@ -5120,6 +5241,7 @@ export {
   readSystemsConfig,
   writeSystemsConfig,
   deleteSystemsConfig,
+  enrichActivityMetadata,
   parseCommandArgs,
   loadAllExtensions,
   getLoadedExtensions,