volute 0.46.0 → 0.48.0

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

@@ -1,82 +1,92 @@
 #!/usr/bin/env node
-import {
-  loadMergedEnv
-} from "./chunk-ZDZISKCL.js";
 import {
   spiritDir
-} from "./chunk-BJZ4PV7R.js";
+} from "./chunk-HNGFKPNS.js";
+import {
+  clearMind,
+  linkInboundToActiveTurn,
+  publish as publish3,
+  summarizeOrphanedTurns
+} from "./chunk-USD45JKR.js";
+import {
+  getPrompt
+} from "./chunk-MOERAQXH.js";
 import {
   hashSkillDir,
   importSkillFromDir,
   removeSharedSkill,
   sharedSkillsDir
-} from "./chunk-KGIXX4NM.js";
+} from "./chunk-HUNDXZBZ.js";
+import {
+  getOrCreateMindUser,
+  getOrCreateSystemUser,
+  getUser,
+  getUserByUsername,
+  syncMindProfile
+} from "./chunk-ODDGGLM6.js";
 import {
   addMessage,
   createChannel,
   createConversation,
   findDMConversation,
   getChannelByName,
+  getChannelSettings,
   getParticipants,
   joinChannel,
-  publish as publish2
-} from "./chunk-5ZQZDDIK.js";
-import {
-  readVoluteConfig,
-  resolveWakeTriggers,
-  writeVoluteConfig
-} from "./chunk-PFZBNKUH.js";
+  publish as publish2,
+  updateChannelSettings
+} from "./chunk-HPGN6XRT.js";
 import {
   isSandboxEnabled,
   wrapForSandbox
-} from "./chunk-JZ62SYWR.js";
+} from "./chunk-VZRA5TYO.js";
+import {
+  MIND_LEVEL_SESSION,
+  recordNotice
+} from "./chunk-IYCV34IU.js";
 import {
   markIdle,
   onMindEvent
-} from "./chunk-KQSFTPIM.js";
+} from "./chunk-MTRMQFCQ.js";
+import {
+  renderAvatarBlock
+} from "./chunk-WQ46E33M.js";
+import {
+  readVoluteConfig,
+  resolveWakeTriggers,
+  writeVoluteConfig
+} from "./chunk-WCFSBH33.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 {
+  loadMergedEnv
+} from "./chunk-IJPMIEVE.js";
 import {
   aiCompleteUtility,
   getAiConfig,
+  missingCredentialWarning,
   resolveApiKey
-} from "./chunk-IHKGWTGT.js";
+} from "./chunk-YNBXEQAP.js";
 import {
   readGlobalConfig,
   writeGlobalConfig
-} from "./chunk-F7H6ATM4.js";
-import {
-  getOrCreateMindUser,
-  getOrCreateSystemUser,
-  getUser,
-  getUserByUsername,
-  syncMindProfile
-} from "./chunk-OV7ZQ2GH.js";
+} from "./chunk-5KXCM5AW.js";
 import {
   publish,
   subscribe
-} from "./chunk-ZNMCCHCP.js";
+} from "./chunk-LTLFOSA4.js";
 import {
   logger_default
 } from "./chunk-T2TP6ZC6.js";
@@ -88,38 +98,39 @@ import {
   isSpiritName,
   mindDir,
   mindTmpDir,
+  readRegistry,
   setMindRunning,
   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";
+import { and as and4, eq as eq5, inArray as inArray3 } from "drizzle-orm";
 
 // packages/daemon/src/lib/daemon/sleep-manager.ts
 import { execFile as execFile2, spawn as spawnChild } from "child_process";
 import {
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   mkdirSync as mkdirSync5,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   readlinkSync,
   renameSync,
   writeFileSync as writeFileSync6
 } from "fs";
-import { resolve as resolve7 } from "path";
+import { resolve as resolve8 } from "path";
 import { promisify as promisify2 } from "util";
 import { CronExpressionParser as CronExpressionParser2 } from "cron-parser";
-import { and as and2, eq as eq3, inArray } from "drizzle-orm";
+import { and, eq as eq2, inArray } from "drizzle-orm";
 
 // packages/daemon/src/lib/daemon/mind-manager.ts
 import { execFile, spawn } from "child_process";
@@ -344,106 +355,6 @@ function getMindToken(mindName) {
   return mindToToken.get(mindName) ?? null;
 }
 
-// packages/daemon/src/lib/daemon/notices.ts
-import { and, asc, eq, lte, or, sql } from "drizzle-orm";
-var nlog = logger_default.child("notices");
-var MIND_LEVEL_SESSION = "";
-var MAX_NOTICES_PER_SESSION = 100;
-async function recordNotice(input) {
-  try {
-    const db = await getDb();
-    await db.insert(mindNotices).values({
-      mind: input.mind,
-      session: input.session,
-      kind: input.kind,
-      reason: input.reason,
-      detail: input.detail,
-      raw: input.raw ?? null
-    });
-    await db.run(
-      sql`DELETE FROM mind_notices WHERE mind = ${input.mind} AND session = ${input.session} AND id NOT IN (SELECT id FROM mind_notices WHERE mind = ${input.mind} AND session = ${input.session} ORDER BY id DESC LIMIT ${MAX_NOTICES_PER_SESSION})`
-    );
-  } catch (err) {
-    nlog.error(`failed to record notice for ${input.mind}:${input.session}`, logger_default.errorData(err));
-  }
-}
-async function drainNotices(mind, session, limit = MAX_NOTICES_PER_SESSION) {
-  const db = await getDb();
-  return db.select().from(mindNotices).where(
-    and(
-      eq(mindNotices.mind, mind),
-      or(eq(mindNotices.session, session), eq(mindNotices.session, MIND_LEVEL_SESSION))
-    )
-  ).orderBy(asc(mindNotices.id)).limit(limit);
-}
-async function clearDeliveredNotices(mind, session, uptoId) {
-  try {
-    const db = await getDb();
-    await db.delete(mindNotices).where(
-      and(
-        eq(mindNotices.mind, mind),
-        or(eq(mindNotices.session, session), eq(mindNotices.session, MIND_LEVEL_SESSION)),
-        lte(mindNotices.id, uptoId)
-      )
-    );
-  } catch (err) {
-    nlog.warn(`failed to clear delivered notices for ${mind}:${session}`, logger_default.errorData(err));
-  }
-}
-var NOTICE_HEADER = "[Notices] While you were unavailable, one or more turns failed. You're back now:";
-function formatNotices(notices) {
-  if (notices.length === 0) return null;
-  const failures = notices.filter((n) => n.kind !== "extension" && n.kind !== "budget");
-  const budgets = notices.filter((n) => n.kind === "budget");
-  const extensions = notices.filter((n) => n.kind === "extension");
-  const blocks = [];
-  if (failures.length > 0) {
-    const groups = /* @__PURE__ */ new Map();
-    for (const n of failures) {
-      const time = localHM(n.created_at);
-      const g = groups.get(n.reason);
-      if (g) {
-        g.count += 1;
-        g.detail = n.detail;
-        g.last = time;
-      } else {
-        groups.set(n.reason, { count: 1, detail: n.detail, first: time, last: time });
-      }
-    }
-    const lines = [...groups.values()].map((g) => {
-      const span = g.first === g.last ? g.first : `${g.first}\u2013${g.last}`;
-      const plural = g.count === 1 ? "turn" : "turns";
-      return `- ${g.count} ${plural} failed (${span}): ${g.detail}`;
-    });
-    blocks.push(`${NOTICE_HEADER}
-${lines.join("\n")}`);
-  }
-  if (budgets.length > 0) {
-    const lines = budgets.map((n) => `- ${localHM(n.created_at)} ${n.detail}`);
-    blocks.push(`[Budget]
-${lines.join("\n")}`);
-  }
-  if (extensions.length > 0) {
-    const byExt = /* @__PURE__ */ new Map();
-    for (const n of extensions) {
-      const arr = byExt.get(n.reason);
-      if (arr) arr.push(n);
-      else byExt.set(n.reason, [n]);
-    }
-    for (const [ext, items] of byExt) {
-      const header = `[${ext.charAt(0).toUpperCase()}${ext.slice(1)}]`;
-      const lines = items.map((n) => `- ${localHM(n.created_at)} ${n.detail}`);
-      blocks.push(`${header}
-${lines.join("\n")}`);
-    }
-  }
-  return blocks.join("\n\n");
-}
-function localHM(createdAt) {
-  const iso = createdAt.endsWith("Z") ? createdAt : `${createdAt.replace(" ", "T")}Z`;
-  return new Date(iso).toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit" });
-}
-
 // packages/daemon/src/lib/daemon/restart-tracker.ts
 var DEFAULT_MAX_ATTEMPTS = 5;
 var DEFAULT_BASE_DELAY = 3e3;
@@ -804,7 +715,7 @@ var MindManager = class {
       while (recentStderr.length > 20) recentStderr.shift();
     });
     try {
-      await new Promise((resolve9, reject) => {
+      await new Promise((resolve10, reject) => {
         let settled = false;
         const deadline = Date.now() + 3e4;
         const onExit = (code) => {
@@ -834,7 +745,7 @@ var MindManager = class {
           const { ok } = await checkHealth(port);
           if (settled) return;
           if (ok) {
-            finish(() => resolve9());
+            finish(() => resolve10());
             return;
           }
           if (Date.now() >= deadline) {
@@ -934,7 +845,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-Z27R3WTW.js");
         const sleepMgr = getSleepManagerIfReady2();
         const sleepState = sleepMgr?.getState(name);
         if (sleepState?.sleeping) {
@@ -964,15 +875,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-HZTT5SJR.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);
@@ -1002,23 +913,23 @@ var MindManager = class {
     this.stopping.add(name);
     const { child } = tracked;
     this.minds.delete(name);
-    await new Promise((resolve9) => {
+    await new Promise((resolve10) => {
       const killTimer = setTimeout(() => {
         try {
           process.kill(-child.pid, "SIGKILL");
         } catch {
         }
-        resolve9();
+        resolve10();
       }, 5e3);
       child.on("exit", () => {
         clearTimeout(killTimer);
-        resolve9();
+        resolve10();
       });
       try {
         process.kill(-child.pid, "SIGTERM");
       } catch {
         clearTimeout(killTimer);
-        resolve9();
+        resolve10();
       }
     });
     this.stopping.delete(name);
@@ -1030,7 +941,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-HZTT5SJR.js");
       getDeliveryManager2().clearMindSessions(name);
     } catch (err) {
       if (!(err instanceof Error && err.message.includes("not initialized"))) {
@@ -1038,7 +949,7 @@ var MindManager = class {
       }
     }
     try {
-      const { clearEchoTextCache } = await import("./echo-text-VQPB5L2X.js");
+      const { clearEchoTextCache } = await import("./echo-text-H3SH337Q.js");
       clearEchoTextCache(name);
     } catch (err) {
       mlog.debug(`failed to clear echo-text cache for ${name}`, logger_default.errorData(err));
@@ -1122,17 +1033,30 @@ function tryGetMindManager() {
   return instance;
 }
 
+// packages/daemon/src/lib/daemon/mind-service.ts
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { resolve as resolve7 } from "path";
+
 // packages/daemon/src/lib/chat/system-channel.ts
 var SYSTEM_CHANNEL_NAME = "system";
+var SYSTEM_CHANNEL_DESCRIPTION = "The commons \u2014 a shared room for every mind and the spirit on this system. Think out loud, check in, riff, coordinate.";
 var cachedChannelId = null;
 async function ensureSystemChannel() {
   if (cachedChannelId) return cachedChannelId;
   const existing = await getChannelByName(SYSTEM_CHANNEL_NAME);
   if (existing) {
     cachedChannelId = existing.id;
+    const settings = await getChannelSettings(SYSTEM_CHANNEL_NAME);
+    if (settings && settings.description == null) {
+      await updateChannelSettings(SYSTEM_CHANNEL_NAME, {
+        description: SYSTEM_CHANNEL_DESCRIPTION
+      });
+    }
     return existing.id;
   }
-  const conv = await createChannel(SYSTEM_CHANNEL_NAME);
+  const conv = await createChannel(SYSTEM_CHANNEL_NAME, void 0, {
+    description: SYSTEM_CHANNEL_DESCRIPTION
+  });
   cachedChannelId = conv.id;
   logger_default.info("created #system channel");
   return conv.id;
@@ -1145,6 +1069,25 @@ async function joinSystemChannelForMind(mindName) {
   const user = await getOrCreateMindUser(mindName);
   await joinSystemChannel(user.id);
 }
+async function joinSystemChannelForSpirit() {
+  const user = await getOrCreateSystemUser();
+  await joinSystemChannel(user.id);
+}
+async function backfillSystemChannelMembers() {
+  const entries = await readRegistry();
+  for (const entry of entries) {
+    if (entry.stage === "seed") continue;
+    try {
+      if (entry.mindType === "spirit") {
+        await joinSystemChannelForSpirit();
+      } else {
+        await joinSystemChannelForMind(entry.name);
+      }
+    } catch (err) {
+      logger_default.error(`failed to backfill ${entry.name} into #system`, logger_default.errorData(err));
+    }
+  }
+}
 async function announceToSystem(text) {
   const channelId = await ensureSystemChannel();
   const systemUser = await getOrCreateSystemUser();
@@ -1174,7 +1117,7 @@ import { dirname, resolve as resolve4 } from "path";
 
 // packages/daemon/src/web/middleware/auth.ts
 import { timingSafeEqual } from "crypto";
-import { eq as eq2, lt } from "drizzle-orm";
+import { eq, lt } from "drizzle-orm";
 import { getCookie } from "hono/cookie";
 import { createMiddleware } from "hono/factory";
 var MIND_USER_CACHE_TTL = 5 * 60 * 1e3;
@@ -1202,14 +1145,14 @@ async function createSession(userId) {
 async function deleteSession(sessionId) {
   sessionCache.delete(sessionId);
   const db = await getDb();
-  await db.delete(sessions).where(eq2(sessions.id, sessionId));
+  await db.delete(sessions).where(eq(sessions.id, sessionId));
 }
 async function getSessionUserId(sessionId) {
   const db = await getDb();
-  const row = await db.select().from(sessions).where(eq2(sessions.id, sessionId)).get();
+  const row = await db.select().from(sessions).where(eq(sessions.id, sessionId)).get();
   if (!row) return void 0;
   if (Date.now() - row.createdAt > SESSION_MAX_AGE) {
-    await db.delete(sessions).where(eq2(sessions.id, sessionId));
+    await db.delete(sessions).where(eq(sessions.id, sessionId));
     return void 0;
   }
   return row.userId;
@@ -1362,10 +1305,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 +1456,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 +1535,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 +1576,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 +1601,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);
@@ -1698,7 +1673,7 @@ function resolveSkillsDir(manifest) {
 async function discoverBuiltinExtensions(disabledIds) {
   const builtins = [
     { id: "notes", load: async () => (await import("./src-YH6PQ7LJ.js")).default },
-    { id: "pages", load: async () => (await import("./src-OJHARHTF.js")).default },
+    { id: "pages", load: async () => (await import("./src-WLJE73NP.js")).default },
     { id: "plan", load: async () => (await import("./src-JAOVXO5W.js")).default }
   ];
   const results = [];
@@ -1948,7 +1923,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 +1944,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(
@@ -2431,10 +2406,17 @@ var Scheduler = class {
 ${stderr}` : ""}`;
           slog2.warn(`script "${schedule.id}" failed for ${mindName}`, logger_default.errorData(err));
         }
+      } else if (Array.isArray(schedule.messages) && schedule.messages.length > 0) {
+        const pick = schedule.messages[Math.floor(Math.random() * schedule.messages.length)];
+        if (typeof pick !== "string" || !pick.trim()) {
+          slog2.warn(`schedule "${schedule.id}" for ${mindName} has a malformed messages pool`);
+          return;
+        }
+        text = pick;
       } else if (schedule.message) {
         text = schedule.message;
       } else {
-        slog2.warn(`schedule "${schedule.id}" for ${mindName} has no message or script`);
+        slog2.warn(`schedule "${schedule.id}" for ${mindName} has no message, messages, or script`);
         return;
       }
       await this.deliverSystem(mindName, `[${schedule.id}] ${text}`, {
@@ -2754,6 +2736,9 @@ async function startMindFull(name) {
     summary: `${name} started`
   }).catch((err) => logger_default.error("failed to publish mind_started activity", logger_default.errorData(err)));
   if (entry?.parent) return;
+  recordMissingCredentialsNotice(baseName, entry?.template).catch(
+    (err) => logger_default.error(`failed to check credentials for ${baseName}`, logger_default.errorData(err))
+  );
   if (!entry || entry.stage === "seed") {
     if (entry?.stage === "seed") {
       sendSeedOrientation(baseName, entry.createdBy).catch(
@@ -2798,6 +2783,31 @@ async function startMindFull(name) {
   }
   notifyExtensionsMindStart(baseName);
 }
+async function recordMissingCredentialsNotice(mind, template) {
+  const { hasUndeliveredNotice, recordNotice: recordNotice2, MIND_LEVEL_SESSION: MIND_LEVEL_SESSION2 } = await import("./notices-2KU5NTRY.js");
+  const warning = await missingCredentialWarning(template, readMindModel(mind, template), mind);
+  if (!warning) return;
+  if (await hasUndeliveredNotice(mind, "no_credentials")) return;
+  await recordNotice2({
+    mind,
+    session: MIND_LEVEL_SESSION2,
+    kind: "startup",
+    reason: "no_credentials",
+    detail: warning
+  });
+}
+function readMindModel(mind, template) {
+  if (template !== "pi") return void 0;
+  try {
+    const configPath2 = resolve7(mindDir(mind), "home/.config/config.json");
+    if (!existsSync8(configPath2)) return void 0;
+    const model = JSON.parse(readFileSync7(configPath2, "utf-8")).model;
+    return typeof model === "string" ? model : void 0;
+  } catch (err) {
+    logger_default.warn(`failed to read model for ${mind}`, logger_default.errorData(err));
+    return void 0;
+  }
+}
 async function sleepMind(name) {
   markIdle(name);
   await getMindManager().stopMind(name);
@@ -2818,10 +2828,13 @@ 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);
+  joinSystemChannelForSpirit().catch(
+    (err) => logger_default.error(`failed to join #system for ${name}`, logger_default.errorData(err))
+  );
   getScheduler().loadSchedules(name, entry?.dir ?? spiritDir());
   publish({
     type: "mind_started",
@@ -2848,14 +2861,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) {
@@ -2951,7 +2964,7 @@ var SleepManager = class {
   transitioning = /* @__PURE__ */ new Set();
   sleepConfigs = /* @__PURE__ */ new Map();
   get statePath() {
-    return resolve7(voluteSystemDir(), "sleep-state.json");
+    return resolve8(voluteSystemDir(), "sleep-state.json");
   }
   start() {
     this.loadState();
@@ -2967,8 +2980,8 @@ var SleepManager = class {
   // --- State persistence ---
   loadState() {
     try {
-      if (existsSync8(this.statePath)) {
-        const data = JSON.parse(readFileSync7(this.statePath, "utf-8"));
+      if (existsSync9(this.statePath)) {
+        const data = JSON.parse(readFileSync8(this.statePath, "utf-8"));
         for (const [name, state2] of Object.entries(data)) {
           state2.triggerWakeHistory ??= [];
           state2.wakeFailures ??= 0;
@@ -3259,7 +3272,7 @@ var SleepManager = class {
   async flushQueuedMessages(name) {
     try {
       const db = await getDb();
-      const rows = await db.select().from(deliveryQueue).where(and2(eq3(deliveryQueue.mind, name), eq3(deliveryQueue.status, "sleep-queued"))).all();
+      const rows = await db.select().from(deliveryQueue).where(and(eq2(deliveryQueue.mind, name), eq2(deliveryQueue.status, "sleep-queued"))).all();
       if (rows.length === 0) return 0;
       const groups = /* @__PURE__ */ new Map();
       for (const row of rows) {
@@ -3271,7 +3284,7 @@ var SleepManager = class {
             `dropping unparseable queued message ${row.id} for ${name}`,
             logger_default.errorData(err)
           );
-          await db.delete(deliveryQueue).where(eq3(deliveryQueue.id, row.id));
+          await db.delete(deliveryQueue).where(eq2(deliveryQueue.id, row.id));
           continue;
         }
         const channel = payload.channel ?? "unknown";
@@ -3314,7 +3327,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-GPQ5SE5N.js");
     return deliverBatch2(name, payloads);
   }
   // --- Wake failure handling (#419) ---
@@ -3492,17 +3505,17 @@ var SleepManager = class {
     }
   }
   async waitForIdle(name, timeoutMs) {
-    return new Promise((resolve9) => {
+    return new Promise((resolve10) => {
       const timeout = setTimeout(() => {
         unsub();
-        resolve9();
+        resolve10();
       }, timeoutMs);
       const unsub = subscribe((event) => {
         if (event.mind !== name) return;
         if (event.type === "mind_done" || event.type === "mind_idle") {
           clearTimeout(timeout);
           unsub();
-          resolve9();
+          resolve10();
         }
       });
     });
@@ -3510,15 +3523,15 @@ var SleepManager = class {
   async archiveSessions(name) {
     const dir = mindDir(name);
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 16);
-    const sessionsDir = resolve7(dir, ".mind", "sessions");
-    if (existsSync8(sessionsDir)) {
-      const archiveDir = resolve7(sessionsDir, "archive");
+    const sessionsDir = resolve8(dir, ".mind", "sessions");
+    if (existsSync9(sessionsDir)) {
+      const archiveDir = resolve8(sessionsDir, "archive");
       mkdirSync5(archiveDir, { recursive: true });
       for (const file of readdirSync2(sessionsDir)) {
         if (file === "archive" || !file.endsWith(".json")) continue;
-        const src = resolve7(sessionsDir, file);
+        const src = resolve8(sessionsDir, file);
         const base = file.replace(/\.json$/, "");
-        const dest = resolve7(archiveDir, `${base}-${timestamp}.json`);
+        const dest = resolve8(archiveDir, `${base}-${timestamp}.json`);
         try {
           renameSync(src, dest);
         } catch (err) {
@@ -3526,14 +3539,14 @@ var SleepManager = class {
         }
       }
     }
-    const piSessionsDir = resolve7(dir, ".mind", "pi-sessions");
-    if (existsSync8(piSessionsDir)) {
-      const archiveDir = resolve7(piSessionsDir, "archive");
+    const piSessionsDir = resolve8(dir, ".mind", "pi-sessions");
+    if (existsSync9(piSessionsDir)) {
+      const archiveDir = resolve8(piSessionsDir, "archive");
       mkdirSync5(archiveDir, { recursive: true });
       for (const entry of readdirSync2(piSessionsDir, { withFileTypes: true })) {
         if (entry.name === "archive" || !entry.isDirectory()) continue;
-        const src = resolve7(piSessionsDir, entry.name);
-        const dest = resolve7(archiveDir, `${entry.name}-${timestamp}`);
+        const src = resolve8(piSessionsDir, entry.name);
+        const dest = resolve8(archiveDir, `${entry.name}-${timestamp}`);
         try {
           renameSync(src, dest);
         } catch (err) {
@@ -3543,8 +3556,8 @@ var SleepManager = class {
     }
   }
   async runWakeContextScript(name, sleepingSince, duration) {
-    const scriptPath = resolve7(mindDir(name), "home", ".local", "hooks", "wake-context.sh");
-    if (!existsSync8(scriptPath)) return "";
+    const scriptPath = resolve8(mindDir(name), "home", ".local", "hooks", "wake-context.sh");
+    if (!existsSync9(scriptPath)) return "";
     const input = JSON.stringify({
       sleepingSince,
       duration,
@@ -3594,7 +3607,7 @@ var SleepManager = class {
   async buildQueuedSummary(name) {
     try {
       const db = await getDb();
-      const rows = await db.select({ channel: deliveryQueue.channel, sender: deliveryQueue.sender }).from(deliveryQueue).where(and2(eq3(deliveryQueue.mind, name), eq3(deliveryQueue.status, "sleep-queued"))).all();
+      const rows = await db.select({ channel: deliveryQueue.channel, sender: deliveryQueue.sender }).from(deliveryQueue).where(and(eq2(deliveryQueue.mind, name), eq2(deliveryQueue.status, "sleep-queued"))).all();
       if (rows.length === 0) return "No messages arrived while you slept.";
       const channelCounts = /* @__PURE__ */ new Map();
       const senders = /* @__PURE__ */ new Set();
@@ -3641,7 +3654,7 @@ var SleepManager = class {
     } catch {
       try {
         const portHex = port.toString(16).toUpperCase().padStart(4, "0");
-        const tcp6 = readFileSync7("/proc/net/tcp6", "utf-8");
+        const tcp6 = readFileSync8("/proc/net/tcp6", "utf-8");
         for (const line of tcp6.split("\n")) {
           if (!line.includes(`:${portHex} `)) continue;
           const fields = line.trim().split(/\s+/);
@@ -3709,9 +3722,9 @@ function getSleepManagerIfReady() {
 }
 
 // packages/daemon/src/lib/delivery/delivery-manager.ts
-import { readFile, realpath } from "fs/promises";
-import { extname, resolve as resolve8 } from "path";
-import { and as and4, eq as eq5, inArray as inArray2, sql as sql2 } from "drizzle-orm";
+import { realpath } from "fs/promises";
+import { resolve as resolve9 } from "path";
+import { and as and3, eq as eq4, inArray as inArray2, sql } from "drizzle-orm";
 
 // packages/daemon/src/lib/chat/typing.ts
 var DEFAULT_TTL_MS = 1e4;
@@ -3805,7 +3818,7 @@ function publishTypingForChannels(channels, map) {
 }
 
 // packages/daemon/src/lib/delivery/send-gate.ts
-import { and as and3, asc as asc2, desc, eq as eq4, gt } from "drizzle-orm";
+import { and as and2, asc, desc, eq as eq3, gt } from "drizzle-orm";
 var state = /* @__PURE__ */ new Map();
 function extractText(raw) {
   if (!raw) return "";
@@ -3820,7 +3833,7 @@ function extractText(raw) {
 }
 async function maxMessageId(conversationId) {
   const db = await getDb();
-  const rows = await db.select({ id: messages.id }).from(messages).where(eq4(messages.conversation_id, conversationId)).orderBy(desc(messages.id)).limit(1);
+  const rows = await db.select({ id: messages.id }).from(messages).where(eq3(messages.conversation_id, conversationId)).orderBy(desc(messages.id)).limit(1);
   return rows[0]?.id ?? 0;
 }
 async function onDeliveredToMind(mindBase, conversationId) {
@@ -3839,7 +3852,7 @@ async function checkStaleSend(mindBase, conversationId, excludeSenders) {
   const entry = state.get(mindBase)?.get(conversationId);
   if (!entry?.turnOpen || entry.heldThisTurn) return { held: false };
   const db = await getDb();
-  const rows = await db.select({ id: messages.id, sender: messages.sender_name, content: messages.content }).from(messages).where(and3(eq4(messages.conversation_id, conversationId), gt(messages.id, entry.baselineId))).orderBy(asc2(messages.id));
+  const rows = await db.select({ id: messages.id, sender: messages.sender_name, content: messages.content }).from(messages).where(and2(eq3(messages.conversation_id, conversationId), gt(messages.id, entry.baselineId))).orderBy(asc(messages.id));
   const excluded = new Set(excludeSenders.filter(Boolean));
   const unseen = rows.filter((r) => r.sender && !excluded.has(r.sender));
   if (unseen.length === 0) return { held: false };
@@ -3876,6 +3889,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 +3911,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-63ABFF6V.js");
+    await sendSystemMessage2(mindName, text);
+  };
   constructor() {
     setRoutesChangeListener((mind) => {
       this.releaseGated(mind).catch(
@@ -3907,6 +3927,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.
@@ -4023,9 +4047,9 @@ var DeliveryManager = class {
     try {
       const db = await getDb();
       rows = await db.select().from(deliveryQueue).where(
-        and4(
-          eq5(deliveryQueue.status, "pending"),
-          sql2`(${deliveryQueue.next_attempt_at} IS NULL OR ${deliveryQueue.next_attempt_at} <= datetime('now'))`
+        and3(
+          eq4(deliveryQueue.status, "pending"),
+          sql`(${deliveryQueue.next_attempt_at} IS NULL OR ${deliveryQueue.next_attempt_at} <= datetime('now'))`
         )
       ).orderBy(deliveryQueue.id).limit(REDRIVE_BATCH_LIMIT);
     } catch (err) {
@@ -4069,9 +4093,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);
@@ -4079,12 +4109,13 @@ var DeliveryManager = class {
     let rows;
     try {
       const db = await getDb();
-      rows = await db.select().from(deliveryQueue).where(and4(eq5(deliveryQueue.mind, baseName), eq5(deliveryQueue.status, "gated")));
+      rows = await db.select().from(deliveryQueue).where(and3(eq4(deliveryQueue.mind, baseName), eq4(deliveryQueue.status, "gated")));
     } catch (err) {
       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,27 +4130,127 @@ 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) return;
+    if (promote.length === 0) {
+      if (truncationNotes.length > 0) await this.sendReleaseSummary(mindName, truncationNotes);
+      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(eq4(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(and3(eq4(channelGates.mind, baseName), eq4(channelGates.channel, channel)));
+      return rows[0]?.state === "declined";
+    } catch (err) {
+      dlog.warn(`failed to read gate state for ${baseName}/${channel}`, logger_default.errorData(err));
+      return false;
+    }
+  }
+  /**
+   * Record that a mind has declined an unrouted channel: future messages are still
+   * persisted (history is preserved) but never notify, and any currently-gated rows are
+   * archived so they're inert. Returns the number of held messages archived. #537
+   */
+  async declineChannel(mindName, channel) {
+    const baseName = await getBaseName(mindName);
+    const db = await getDb();
+    await db.insert(channelGates).values({ mind: baseName, channel, state: "declined" }).onConflictDoUpdate({
+      target: [channelGates.mind, channelGates.channel],
+      set: { state: "declined", updated_at: sql`(datetime('now'))` }
+    });
+    const archived = await db.update(deliveryQueue).set({ status: "archived" }).where(
+      and3(
+        eq4(deliveryQueue.mind, baseName),
+        eq4(deliveryQueue.channel, channel),
+        eq4(deliveryQueue.status, "gated")
+      )
+    ).returning({ id: deliveryQueue.id });
+    dlog.info(
+      `declined channel ${channel} for ${baseName}; archived ${archived.length} held row(s)`
+    );
+    return archived.length;
+  }
+  /**
+   * Send the mind a single summary when a routing change released a truncated backlog,
+   * rather than a flood of individual messages. #537
+   */
+  async sendReleaseSummary(mindName, notes) {
+    const body = [
+      `[Channel backlog released]`,
+      `A routing change matched channel(s) that had held messages while unrouted. To avoid flooding you, only the ${GATED_RELEASE_LIMIT_PER_CHANNEL} most recent per channel were delivered:`,
+      "",
+      ...notes.map((n) => `- ${n}`)
+    ].join("\n");
+    try {
+      await this.notify(mindName, body);
+    } catch (err) {
+      dlog.warn(`failed to send release summary for ${mindName}`, logger_default.errorData(err));
+    }
+  }
   /**
    * Get pending (gated) messages for a mind.
    */
   async getPending(mindName) {
     const db = await getDb();
-    const rows = await db.select().from(deliveryQueue).where(and4(eq5(deliveryQueue.mind, mindName), eq5(deliveryQueue.status, "gated")));
+    const rows = await db.select().from(deliveryQueue).where(and3(eq4(deliveryQueue.mind, mindName), eq4(deliveryQueue.status, "gated")));
     const byChannel = /* @__PURE__ */ new Map();
     for (const row of rows) {
       const ch = row.channel ?? "unknown";
@@ -4289,7 +4420,7 @@ var DeliveryManager = class {
         const backoffSec = Math.round(
           Math.min(RETRY_MAX_MS, RETRY_BASE_MS * 2 ** Math.min(attempts, 20)) / 1e3
         );
-        await db.update(deliveryQueue).set({ attempts, next_attempt_at: sql2`datetime('now', ${`+${backoffSec} seconds`})` }).where(eq5(deliveryQueue.id, row.id));
+        await db.update(deliveryQueue).set({ attempts, next_attempt_at: sql`datetime('now', ${`+${backoffSec} seconds`})` }).where(eq4(deliveryQueue.id, row.id));
       }
     } catch (err) {
       dlog.warn("failed to schedule delivery retry", logger_default.errorData(err));
@@ -4513,41 +4644,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(
-        and4(
-          eq5(deliveryQueue.mind, baseName),
-          eq5(deliveryQueue.channel, payload.channel),
-          eq5(deliveryQueue.status, "gated")
+      const rows = await db.select({ count: sql`count(*)` }).from(deliveryQueue).where(
+        and3(
+          eq4(deliveryQueue.mind, baseName),
+          eq4(deliveryQueue.channel, payload.channel),
+          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 +4746,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 {
@@ -4632,8 +4754,8 @@ var DeliveryManager = class {
           const dir = mindDir(p.username);
           const config = readVoluteConfig(dir);
           if (!config?.profile?.avatar) continue;
-          filePath = resolve8(dir, "home", config.profile.avatar);
-          const homeDir = resolve8(dir, "home");
+          filePath = resolve9(dir, "home", config.profile.avatar);
+          const homeDir = resolve9(dir, "home");
           if (!filePath.startsWith(`${homeDir}/`)) {
             dlog.warn(`avatar path for ${p.username} escapes home directory, skipping`);
             continue;
@@ -4652,34 +4774,10 @@ var DeliveryManager = class {
             throw err;
           }
         } 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)
-            );
-          }
+          filePath = resolve9(voluteHome(), "avatars", p.avatar);
         }
-        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") {
@@ -4804,7 +4902,7 @@ async function linkToolResultToTurn(mind, turnId, toolResultContent, toolUseEven
         content: mindHistory.content,
         message_id: mindHistory.message_id,
         turn_id: mindHistory.turn_id
-      }).from(mindHistory).where(and5(eq6(mindHistory.id, outboundId), eq6(mindHistory.mind, mind))).limit(1);
+      }).from(mindHistory).where(and4(eq5(mindHistory.id, outboundId), eq5(mindHistory.mind, mind))).limit(1);
       const row = rows[0];
       if (!row) {
         dlog2.warn(`outbound marker references missing record: mind=${mind} id=${outboundId}`);
@@ -4812,13 +4910,13 @@ async function linkToolResultToTurn(mind, turnId, toolResultContent, toolUseEven
       }
       const alreadyTagged = row.turn_id != null;
       if (!alreadyTagged) {
-        await db.update(mindHistory).set({ turn_id: turnId }).where(eq6(mindHistory.id, outboundId));
+        await db.update(mindHistory).set({ turn_id: turnId }).where(eq5(mindHistory.id, outboundId));
       }
       if (row.message_id) {
         await db.update(messages).set({
           turn_id: turnId,
           ...toolUseEventId != null ? { source_event_id: toolUseEventId } : {}
-        }).where(eq6(messages.id, Number(row.message_id)));
+        }).where(eq5(messages.id, Number(row.message_id)));
       }
       if (!alreadyTagged) {
         publish3(mind, {
@@ -5007,7 +5105,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-Z27R3WTW.js");
     const sm = getSleepManagerIfReady2();
     if (sm?.isSleeping(SPIRIT_NAME)) return true;
   } catch (err) {
@@ -5035,7 +5133,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-Z27R3WTW.js");
     const sm = getSleepManagerIfReady2();
     if (sm) {
       const state2 = sm.getState(mindName);
@@ -5089,10 +5187,6 @@ export {
   checkHealth,
   RotatingLog,
   syncProviderToMinds,
-  recordNotice,
-  drainNotices,
-  clearDeliveredNotices,
-  formatNotices,
   RestartTracker,
   getTypingMap,
   isConversationId,
@@ -5120,6 +5214,7 @@ export {
   readSystemsConfig,
   writeSystemsConfig,
   deleteSystemsConfig,
+  enrichActivityMetadata,
   parseCommandArgs,
   loadAllExtensions,
   getLoadedExtensions,
@@ -5140,6 +5235,7 @@ export {
   initTokenBudget,
   getTokenBudget,
   startMindFull,
+  recordMissingCredentialsNotice,
   sleepMind,
   wakeMind,
   startSpiritFull,
@@ -5159,5 +5255,6 @@ export {
   deliverBatch,
   ensureSystemChannel,
   joinSystemChannel,
+  backfillSystemChannelMembers,
   announceToSystem
 };