volute 0.45.2 → 0.47.0

package/dist/{chunk-YT7PEESJ.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-FR6S2KNN.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-7ZUB63PS.js";
+} from "./chunk-IWJSNMSY.js";
 import {
   addMessage,
   createChannel,
@@ -20,61 +29,57 @@ import {
   getParticipants,
   joinChannel,
   publish as publish2
-} from "./chunk-OP4JG2BS.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-EJVPTVTI.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,
-  getPrompt,
-  linkInboundToActiveTurn,
-  publish as publish3,
-  summarizeOrphanedTurns
-} from "./chunk-UYLGEDVD.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-T6HYVHPG.js";
+} from "./chunk-ODDGGLM6.js";
 import {
   publish,
   subscribe
-} from "./chunk-7C44R625.js";
+} from "./chunk-LTLFOSA4.js";
 import {
   logger_default
 } from "./chunk-T2TP6ZC6.js";
@@ -90,18 +95,19 @@ 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 inArray2 } from "drizzle-orm";
+import { and as and5, eq as eq6, inArray as inArray3 } from "drizzle-orm";
 
 // packages/daemon/src/lib/daemon/sleep-manager.ts
 import { execFile as execFile2, spawn as spawnChild } from "child_process";
@@ -117,7 +123,7 @@ import {
 import { resolve as resolve7 } from "path";
 import { promisify as promisify2 } from "util";
 import { CronExpressionParser as CronExpressionParser2 } from "cron-parser";
-import { and as and2, eq as eq3 } from "drizzle-orm";
+import { and as and2, eq as eq3, inArray } from "drizzle-orm";
 
 // packages/daemon/src/lib/daemon/mind-manager.ts
 import { execFile, spawn } from "child_process";
@@ -769,21 +775,8 @@ var MindManager = class {
     if (isIsolationEnabled()) {
       env.HOME = resolve2(dir, "home");
     }
-    const customNode = process.env.VOLUTE_NODE_PATH;
-    let baseBin;
-    let baseArgs;
-    if (customNode) {
-      baseBin = customNode;
-      baseArgs = [
-        resolve2(dir, "node_modules", ".bin", "tsx"),
-        "src/server.ts",
-        "--port",
-        String(port)
-      ];
-    } else {
-      baseBin = resolve2(dir, "node_modules", ".bin", "tsx");
-      baseArgs = ["src/server.ts", "--port", String(port)];
-    }
+    const baseBin = process.env.VOLUTE_NODE_PATH ?? process.execPath;
+    const baseArgs = ["--import", "tsx", "src/server.ts", "--port", String(port)];
     let spawnCmd;
     let spawnArgs;
     if (isIsolationEnabled()) {
@@ -945,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-HCUH4PM4.js");
+        const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-3NA7ZJP3.js");
         const sleepMgr = getSleepManagerIfReady2();
         const sleepState = sleepMgr?.getState(name);
         if (sleepState?.sleeping) {
@@ -975,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-VDVKVA46.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-POBLU3LC.js").then(({ markIdle: markIdle2 }) => markIdle2(name)).catch((err) => mlog.warn(`failed to mark ${name} idle after crash`, logger_default.errorData(err)));
-      import("./activity-events-BUR2RYTJ.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);
@@ -1041,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-VDVKVA46.js");
+      const { getDeliveryManager: getDeliveryManager2 } = await import("./delivery-manager-TN5KK2AP.js");
       getDeliveryManager2().clearMindSessions(name);
     } catch (err) {
       if (!(err instanceof Error && err.message.includes("not initialized"))) {
@@ -1049,7 +1042,7 @@ var MindManager = class {
       }
     }
     try {
-      const { clearEchoTextCache } = await import("./echo-text-6JJOPUD4.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));
@@ -1226,6 +1219,10 @@ async function getSessionUserId(sessionId) {
   return row.userId;
 }
 async function cleanExpiredSessions() {
+  const now = Date.now();
+  for (const [id, cached] of sessionCache) {
+    if (cached.expires <= now) sessionCache.delete(id);
+  }
   const db = await getDb();
   const cutoff = Date.now() - SESSION_MAX_AGE;
   await db.delete(sessions).where(lt(sessions.createdAt, cutoff));
@@ -1369,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;
@@ -1476,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))
       );
@@ -1561,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(
@@ -1608,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",
@@ -1633,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);
@@ -1955,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) {
@@ -1976,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(
@@ -2306,6 +2335,7 @@ async function ensureMailAddress(mindName) {
 import { resolve as resolve5 } from "path";
 import { CronExpressionParser } from "cron-parser";
 var slog2 = logger_default.child("scheduler");
+var CATCHUP_STALE_MINUTES = 10;
 var Scheduler = class {
   schedules = /* @__PURE__ */ new Map();
   mindDirs = /* @__PURE__ */ new Map();
@@ -2345,6 +2375,26 @@ var Scheduler = class {
     } else {
       this.schedules.delete(mindName);
     }
+    const epochMinute = Math.floor(Date.now() / 6e4);
+    const validKeys = new Set(schedules.map((s) => `${mindName}:${s.id}`));
+    let changed = false;
+    for (const key of this.lastFired.keys()) {
+      if (key.startsWith(`${mindName}:`) && !validKeys.has(key)) {
+        this.lastFired.delete(key);
+        changed = true;
+      }
+    }
+    for (const key of validKeys) {
+      if (!this.lastFired.has(key)) {
+        this.lastFired.set(key, epochMinute);
+        changed = true;
+      }
+    }
+    if (changed) {
+      this.saveState().catch(
+        (err) => slog2.warn(`failed to persist scheduler state for ${mindName}`, logger_default.errorData(err))
+      );
+    }
   }
   unloadSchedules(mindName) {
     this.schedules.delete(mindName);
@@ -2390,11 +2440,14 @@ var Scheduler = class {
         return false;
       }
     }
-    if (prevMinute === epochMinute) {
-      this.lastFired.set(key, epochMinute);
-      return true;
+    const lastFired = this.lastFired.get(key) ?? epochMinute;
+    if (prevMinute <= lastFired) return false;
+    this.lastFired.set(key, prevMinute);
+    if (epochMinute - prevMinute > CATCHUP_STALE_MINUTES) {
+      slog2.info(`skipping stale catch-up fire for ${key} (${epochMinute - prevMinute}min late)`);
+      return false;
     }
-    return false;
+    return true;
   }
   async fire(mindName, schedule) {
     try {
@@ -2739,11 +2792,7 @@ async function startMindFull(name) {
   if (entry?.parent) return;
   if (!entry || entry.stage === "seed") {
     if (entry?.stage === "seed") {
-      const creatorNote = entry.createdBy ? ` Your creator is ${entry.createdBy}. Send them a message to introduce yourself.` : "";
-      sendSystemMessage(
-        baseName,
-        `You've just been created. A human planted you as a seed. Start a conversation with them \u2014 introduce yourself, ask questions, and begin exploring who you want to be.${creatorNote}`
-      ).catch(
+      sendSeedOrientation(baseName, entry.createdBy).catch(
         (err) => logger_default.error(`failed to send seed orientation for ${baseName}`, logger_default.errorData(err))
       );
       if (entry.createdBy) {
@@ -2805,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);
@@ -2826,9 +2875,23 @@ async function stopSpiritFull(name) {
     summary: `${name} spirit stopped`
   }).catch((err) => logger_default.error("failed to publish spirit_stopped activity", logger_default.errorData(err)));
 }
+function buildSeedOrientation(createdBy, creatorType) {
+  const intro = "You've just been created as a seed. Start a conversation \u2014 introduce yourself, ask questions, and begin exploring who you want to be.";
+  if (!createdBy) return intro;
+  const who = creatorType === "mind" ? `another mind, ${createdBy}` : creatorType === "system" ? `the spirit of this system (${createdBy})` : createdBy;
+  return `${intro} Your creator is ${who}. Send them a message to introduce yourself.`;
+}
+async function sendSeedOrientation(mindName, createdBy) {
+  let creatorType;
+  if (createdBy) {
+    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-FLAEXXZK.js");
-  const { findDMConversation: findDMConversation2, createConversation: createConversation2 } = await import("./conversations-JZTD6KLR.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) {
@@ -2873,7 +2936,8 @@ function defaultState() {
     queuedMessageCount: 0,
     triggerWakeHistory: [],
     wakeFailures: 0,
-    nextWakeAttemptAt: null
+    nextWakeAttemptAt: null,
+    lastWakeAt: null
   };
 }
 function formatCurrentDate() {
@@ -2945,6 +3009,7 @@ var SleepManager = class {
           state2.triggerWakeHistory ??= [];
           state2.wakeFailures ??= 0;
           state2.nextWakeAttemptAt ??= null;
+          state2.lastWakeAt ??= null;
           this.states.set(name, state2);
         }
       }
@@ -2955,7 +3020,7 @@ var SleepManager = class {
   saveState() {
     const data = {};
     for (const [name, state2] of this.states) {
-      if (state2.sleeping) data[name] = state2;
+      if (state2.sleeping || state2.lastWakeAt) data[name] = state2;
     }
     try {
       writeFileSync6(this.statePath, `${JSON.stringify(data, null, 2)}
@@ -3005,8 +3070,9 @@ var SleepManager = class {
       }
       await this.archiveSessions(name);
       state2.sleeping = true;
-      state2.sleepingSince = (/* @__PURE__ */ new Date()).toISOString();
-      state2.scheduledWakeAt = this.getNextWakeTime(this.getSleepConfig(name));
+      if (!state2.voluntaryWakeAt) {
+        state2.scheduledWakeAt = this.getNextWakeTime(this.getSleepConfig(name));
+      }
       this.saveState();
       slog3.info(`${name} returned to sleep after crashing during trigger wake`);
     } catch (err) {
@@ -3162,6 +3228,7 @@ var SleepManager = class {
         } catch (err) {
           slog3.warn(`failed to deliver wake summary to ${name}`, logger_default.errorData(err));
         }
+        await this.waitForIdle(name, 12e4);
       }
       const flushed = await this.flushQueuedMessages(name);
       if (flushed > 0) {
@@ -3219,14 +3286,18 @@ var SleepManager = class {
     }
   }
   /**
-   * Flush all queued sleep messages for a mind through the delivery manager.
+   * Flush all queued sleep messages for a mind on wake. Rows are grouped by channel
+   * and each channel group is delivered as ONE pre-batched turn (#382) — a night's
+   * backlog becomes one stack per channel, not N cold-start doorbells. Delivery is
+   * all-or-nothing per channel: a failed group's rows stay queued for the next wake,
+   * while other channels still flush.
    */
   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();
       if (rows.length === 0) return 0;
-      let deliveredCount = 0;
+      const groups = /* @__PURE__ */ new Map();
       for (const row of rows) {
         let payload;
         try {
@@ -3239,13 +3310,29 @@ var SleepManager = class {
           await db.delete(deliveryQueue).where(eq3(deliveryQueue.id, row.id));
           continue;
         }
-        const delivered = await this.deliverQueued(name, payload);
+        const channel = payload.channel ?? "unknown";
+        if (!groups.has(channel)) groups.set(channel, []);
+        groups.get(channel)?.push({ id: row.id, payload });
+      }
+      let deliveredCount = 0;
+      for (const [channel, items] of groups) {
+        const delivered = await this.deliverQueuedBatch(
+          name,
+          items.map((i) => i.payload)
+        );
         if (!delivered) {
-          slog3.warn(`failed to flush queued message ${row.id} for ${name}; leaving it queued`);
-          break;
+          slog3.warn(
+            `failed to flush ${items.length} queued message(s) on ${channel} for ${name}; leaving them queued`
+          );
+          continue;
         }
-        await db.delete(deliveryQueue).where(eq3(deliveryQueue.id, row.id));
-        deliveredCount++;
+        await db.delete(deliveryQueue).where(
+          inArray(
+            deliveryQueue.id,
+            items.map((i) => i.id)
+          )
+        );
+        deliveredCount += items.length;
       }
       const state2 = this.states.get(name);
       if (state2) {
@@ -3258,14 +3345,13 @@ var SleepManager = class {
     }
   }
   /**
-   * Deliver one queued message on the wake path. `isFlush` skips the queue-time inbound
-   * recording (kept once, at arrival) and bypasses the sleep re-queue so the now-waking mind
-   * actually receives it. Returns whether the message was handed off to the delivery manager.
-   * Extracted as a seam so the flush loop can be unit-tested without the real delivery stack.
+   * Deliver one channel's worth of queued messages as a single pre-batched turn on
+   * the wake path. Extracted as a seam so the flush loop can be unit-tested without
+   * the real delivery stack. Returns whether the batch was handed off to the mind.
    */
-  async deliverQueued(name, payload) {
-    const { deliverMessage: deliverMessage2 } = await import("./message-delivery-3C65ZI6L.js");
-    return deliverMessage2(name, payload, { isFlush: true });
+  async deliverQueuedBatch(name, payloads) {
+    const { deliverBatch: deliverBatch2 } = await import("./message-delivery-ZE3YGJDD.js");
+    return deliverBatch2(name, payloads);
   }
   // --- Wake failure handling (#419) ---
   /**
@@ -3307,7 +3393,8 @@ var SleepManager = class {
    */
   async markWakeErrored(name, err) {
     const detail = err instanceof Error ? err.message : String(err);
-    this.markAwake(name);
+    this.states.delete(name);
+    this.saveState();
     slog3.error(
       `${name} failed to wake ${MAX_WAKE_ATTEMPTS} times in a row; giving up and marking errored`,
       logger_default.errorData(err)
@@ -3336,19 +3423,22 @@ var SleepManager = class {
     const state2 = {
       sleeping: true,
       sleepingSince: (/* @__PURE__ */ new Date()).toISOString(),
-      scheduledWakeAt: this.getNextWakeTime(sleepConfig),
+      // An explicit voluntary wake-at is authoritative for the night — null out
+      // the cron wake so an earlier scheduled wake can't silently override it.
+      scheduledWakeAt: opts?.voluntaryWakeAt ? null : this.getNextWakeTime(sleepConfig),
       wokenByTrigger: false,
       voluntaryWakeAt: opts?.voluntaryWakeAt ?? null,
       queuedMessageCount: this.states.get(name)?.queuedMessageCount ?? 0,
       triggerWakeHistory: [],
       wakeFailures: 0,
-      nextWakeAttemptAt: null
+      nextWakeAttemptAt: null,
+      lastWakeAt: this.states.get(name)?.lastWakeAt ?? null
     };
     this.states.set(name, state2);
     this.saveState();
   }
   markAwake(name) {
-    this.states.delete(name);
+    this.states.set(name, { ...defaultState(), lastWakeAt: (/* @__PURE__ */ new Date()).toISOString() });
     this.saveState();
   }
   getNextWakeTime(config) {
@@ -3363,55 +3453,78 @@ var SleepManager = class {
   }
   async tick() {
     const now = /* @__PURE__ */ new Date();
-    const epochMinute = Math.floor(now.getTime() / 6e4);
     const mindNames = /* @__PURE__ */ new Set([...this.sleepConfigs.keys(), ...this.states.keys()]);
     for (const name of mindNames) {
-      if (!this.isSleeping(name)) {
-        const mind = await findMind(name);
-        if (!mind?.running) continue;
-      }
-      const config = this.getSleepConfig(name);
-      if (!config?.enabled || !config.schedule) continue;
-      const state2 = this.states.get(name);
-      if (state2?.sleeping && state2.nextWakeAttemptAt && now < new Date(state2.nextWakeAttemptAt)) {
-        continue;
-      }
-      if (state2?.sleeping && state2.voluntaryWakeAt) {
-        const wakeAt = new Date(state2.voluntaryWakeAt);
-        if (now >= wakeAt) {
-          this.initiateWake(name).catch(
-            (err) => slog3.error(`failed voluntary wake for ${name}`, logger_default.errorData(err))
-          );
-          continue;
-        }
-      }
-      if (state2?.sleeping && state2.scheduledWakeAt) {
-        const wakeAt = new Date(state2.scheduledWakeAt);
-        if (now >= wakeAt) {
-          this.initiateWake(name).catch(
-            (err) => slog3.error(`failed scheduled wake for ${name}`, logger_default.errorData(err))
-          );
-          continue;
-        }
+      await this.evaluateMind(name, now);
+    }
+  }
+  /**
+   * Per-mind tick evaluation. The wake checks depend only on the persisted sleep
+   * state — never on a currently-enabled sleep config — so a mind that was put to
+   * sleep with a wake time still wakes even if the schedule is later disabled or
+   * removed (or never existed, e.g. a bare `clock sleep --wake-at`). Only the
+   * sleep-onset check requires a running mind with an enabled schedule.
+   */
+  async evaluateMind(name, now) {
+    const state2 = this.states.get(name);
+    if (state2?.sleeping) {
+      if (state2.nextWakeAttemptAt && now < new Date(state2.nextWakeAttemptAt)) return;
+      if (state2.voluntaryWakeAt && now >= new Date(state2.voluntaryWakeAt)) {
+        this.initiateWake(name).catch(
+          (err) => slog3.error(`failed voluntary wake for ${name}`, logger_default.errorData(err))
+        );
+        return;
       }
-      if (!state2?.sleeping) {
-        if (this.shouldSleep(config.schedule.sleep, epochMinute)) {
-          this.initiateSleep(name).catch(
-            (err) => slog3.error(`failed to initiate sleep for ${name}`, logger_default.errorData(err))
-          );
-        }
+      if (state2.scheduledWakeAt && now >= new Date(state2.scheduledWakeAt)) {
+        this.initiateWake(name).catch(
+          (err) => slog3.error(`failed scheduled wake for ${name}`, logger_default.errorData(err))
+        );
+        return;
       }
+      return;
+    }
+    const mind = await findMind(name);
+    if (!mind?.running) return;
+    const config = this.getSleepConfig(name);
+    if (!config?.enabled || !config.schedule) return;
+    if (this.shouldSleepNow(config.schedule, state2?.lastWakeAt ?? null, now)) {
+      this.initiateSleep(name).catch(
+        (err) => slog3.error(`failed to initiate sleep for ${name}`, logger_default.errorData(err))
+      );
     }
   }
-  shouldSleep(cronExpr, epochMinute) {
+  /**
+   * Level-triggered sleep-onset decision: sleep whenever we're inside the nightly
+   * window, not only on the exact sleep minute — so a daemon restart or a stalled
+   * tick across the sleep minute still puts the mind to bed on the next tick.
+   *
+   * Manual-wake exemption: a full wake inside the current window (human
+   * `clock wake`, or a scheduled wake) suppresses re-sleep until the next window
+   * begins, so `volute clock wake` at 3am sticks instead of being undone a minute
+   * later.
+   */
+  shouldSleepNow(schedule, lastWakeAt, now) {
+    const { inWindow, windowStart } = this.inSleepWindow(schedule, now);
+    if (!inWindow || !windowStart) return false;
+    if (lastWakeAt && new Date(lastWakeAt) >= windowStart) return false;
+    return true;
+  }
+  /**
+   * Whether `now` falls inside the mind's nightly sleep window: the most recent
+   * sleep-cron fire is more recent than the most recent wake-cron fire. Returns
+   * the window start (last sleep fire) for the manual-wake exemption check.
+   */
+  inSleepWindow(schedule, now) {
     try {
-      const interval = CronExpressionParser2.parse(cronExpr);
-      const prev = interval.prev().toDate();
-      const prevMinute = Math.floor(prev.getTime() / 6e4);
-      return prevMinute === epochMinute;
+      const prevSleep = CronExpressionParser2.parse(schedule.sleep, { currentDate: now }).prev().toDate();
+      const prevWake = CronExpressionParser2.parse(schedule.wake, { currentDate: now }).prev().toDate();
+      return { inWindow: prevSleep > prevWake, windowStart: prevSleep };
     } catch (err) {
-      slog3.warn(`invalid sleep cron "${cronExpr}"`, logger_default.errorData(err));
-      return false;
+      slog3.warn(
+        `invalid sleep/wake cron "${schedule.sleep}"/"${schedule.wake}"`,
+        logger_default.errorData(err)
+      );
+      return { inWindow: false, windowStart: null };
     }
   }
   async waitForIdle(name, timeoutMs) {
@@ -3603,9 +3716,10 @@ var SleepManager = class {
       this.transitioning.add(event.mind);
       sleepMind(event.mind).then(() => this.archiveSessions(event.mind)).then(() => {
         state2.sleeping = true;
-        state2.sleepingSince = (/* @__PURE__ */ new Date()).toISOString();
-        const sleepConfig = this.getSleepConfig(event.mind);
-        state2.scheduledWakeAt = this.getNextWakeTime(sleepConfig);
+        if (!state2.voluntaryWakeAt) {
+          const sleepConfig = this.getSleepConfig(event.mind);
+          state2.scheduledWakeAt = this.getNextWakeTime(sleepConfig);
+        }
         this.saveState();
         slog3.info(`${event.mind} returned to sleep`);
       }).catch((err) => {
@@ -3631,9 +3745,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, sql as sql2 } from "drizzle-orm";
+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
 var DEFAULT_TTL_MS = 1e4;
@@ -3772,13 +3886,11 @@ async function checkStaleSend(mindBase, conversationId, excludeSenders) {
     unseen: unseen.map((r) => ({ sender: r.sender, text: extractText(r.content) }))
   };
 }
+function clearMind2(mindBase) {
+  state.delete(mindBase);
+}
 function resetTurn(mindBase) {
-  const conv = state.get(mindBase);
-  if (!conv) return;
-  for (const entry of conv.values()) {
-    entry.turnOpen = false;
-    entry.heldThisTurn = false;
-  }
+  clearMind2(mindBase);
 }
 function formatHoldNotice(channelLabel, unseen) {
   const lines = unseen.map((m) => {
@@ -3800,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;
@@ -3820,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(
@@ -3831,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.
@@ -3993,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);
@@ -4008,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 {
@@ -4023,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) 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(inArray(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.
    */
@@ -4088,6 +4318,7 @@ var DeliveryManager = class {
    */
   clearMindSessions(mindName) {
     this.sessionStates.delete(mindName);
+    clearMind2(mindName);
     const toDelete = [];
     for (const [bufferKey, buffer] of this.batchBuffers) {
       if (bufferKey.startsWith(`${mindName}:`)) {
@@ -4195,7 +4426,7 @@ var DeliveryManager = class {
     if (valid.length === 0) return;
     try {
       const db = await getDb();
-      await db.delete(deliveryQueue).where(inArray(deliveryQueue.id, valid));
+      await db.delete(deliveryQueue).where(inArray2(deliveryQueue.id, valid));
     } catch (err) {
       dlog.warn("failed to delete delivered delivery queue rows", logger_default.errorData(err));
     }
@@ -4206,7 +4437,7 @@ var DeliveryManager = class {
     if (valid.length === 0) return;
     try {
       const db = await getDb();
-      const rows = await db.select({ id: deliveryQueue.id, attempts: deliveryQueue.attempts }).from(deliveryQueue).where(inArray(deliveryQueue.id, valid));
+      const rows = await db.select({ id: deliveryQueue.id, attempts: deliveryQueue.attempts }).from(deliveryQueue).where(inArray2(deliveryQueue.id, valid));
       for (const row of rows) {
         const attempts = row.attempts + 1;
         const backoffSec = Math.round(
@@ -4436,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-XOALE2RD.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
@@ -4535,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 {
@@ -4577,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") {
@@ -4610,7 +4808,11 @@ var DeliveryManager = class {
         }
       }
     }
-    avatarBlocksCache.set(cacheKey, { blocks, expiresAt: Date.now() + AVATAR_CACHE_TTL });
+    const now = Date.now();
+    for (const [key, entry] of avatarBlocksCache) {
+      if (entry.expiresAt <= now) avatarBlocksCache.delete(key);
+    }
+    avatarBlocksCache.set(cacheKey, { blocks, expiresAt: now + AVATAR_CACHE_TTL });
     return blocks;
   }
   incrementActive(mind, session, senders, channels) {
@@ -4761,8 +4963,8 @@ async function linkToolResultToTurn(mind, turnId, toolResultContent, toolUseEven
       await db.update(activity).set({
         turn_id: turnId,
         ...toolUseEventId != null ? { source_event_id: toolUseEventId } : {}
-      }).where(inArray2(activity.id, activityIds));
-      const actRows = await db.select().from(activity).where(inArray2(activity.id, activityIds));
+      }).where(inArray3(activity.id, activityIds));
+      const actRows = await db.select().from(activity).where(inArray3(activity.id, activityIds));
       if (actRows.length > 0) {
         await db.insert(mindHistory).values(
           actRows.map((a) => ({
@@ -4826,6 +5028,40 @@ async function deliverMessage(mindName, payload, opts = {}) {
     return false;
   }
 }
+async function deliverBatch(mindName, payloads) {
+  if (payloads.length === 0) return true;
+  try {
+    const baseName = await getBaseName(mindName);
+    const entry = await findMind(baseName);
+    if (!entry) {
+      dlog2.warn(`cannot deliver batch to ${mindName}: mind not found`);
+      return false;
+    }
+    const channels = {};
+    for (const p of payloads) {
+      const ch = p.channel ?? "unknown";
+      if (!channels[ch]) channels[ch] = [];
+      channels[ch].push(p);
+    }
+    const first = payloads[0];
+    const route = resolveRoute(getRoutingConfig(baseName), {
+      channel: first.channel,
+      sender: first.sender ?? void 0,
+      isDM: first.isDM,
+      participantCount: first.participantCount
+    });
+    const session = first.session ?? (route.destination === "mind" ? route.session : "main");
+    const res = await fetch(`http://127.0.0.1:${entry.port}/message`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ session, batch: { channels } })
+    });
+    return res.ok;
+  } catch (err) {
+    dlog2.warn(`unexpected error delivering batch to ${mindName}`, logger_default.errorData(err));
+    return false;
+  }
+}
 
 // packages/daemon/src/lib/chat/system-chat.ts
 var slog4 = logger_default.child("system-chat");
@@ -4879,6 +5115,10 @@ async function sendSystemMessage(mindName, text, opts) {
   });
 }
 async function sendSystemMessageDirect(mindName, text) {
+  if (isSpiritName(mindName)) {
+    await recordInbound(mindName, "@volute", "volute", text);
+    return {};
+  }
   const { conversationId } = await ensureSystemDM(mindName);
   await addMessage(conversationId, "user", "volute", [{ type: "text", text }]);
   await recordInbound(mindName, "@volute", "volute", text);
@@ -4888,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-HCUH4PM4.js");
+    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-3NA7ZJP3.js");
     const sm = getSleepManagerIfReady2();
     if (sm?.isSleeping(SPIRIT_NAME)) return true;
   } catch (err) {
@@ -4916,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-HCUH4PM4.js");
+    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-3NA7ZJP3.js");
     const sm = getSleepManagerIfReady2();
     if (sm) {
       const state2 = sm.getState(mindName);
@@ -5001,6 +5241,7 @@ export {
   readSystemsConfig,
   writeSystemsConfig,
   deleteSystemsConfig,
+  enrichActivityMetadata,
   parseCommandArgs,
   loadAllExtensions,
   getLoadedExtensions,
@@ -5025,6 +5266,7 @@ export {
   wakeMind,
   startSpiritFull,
   stopSpiritFull,
+  buildSeedOrientation,
   stopMindFull,
   matchesGlob,
   SleepManager,
@@ -5036,6 +5278,7 @@ export {
   linkToolResultToTurn,
   resolveSleepAction,
   deliverMessage,
+  deliverBatch,
   ensureSystemChannel,
   joinSystemChannel,
   announceToSystem