volute 0.45.2 → 0.46.0

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

@@ -4,13 +4,13 @@ import {
 } from "./chunk-ZDZISKCL.js";
 import {
   spiritDir
-} from "./chunk-FR6S2KNN.js";
+} from "./chunk-BJZ4PV7R.js";
 import {
   hashSkillDir,
   importSkillFromDir,
   removeSharedSkill,
   sharedSkillsDir
-} from "./chunk-7ZUB63PS.js";
+} from "./chunk-KGIXX4NM.js";
 import {
   addMessage,
   createChannel,
@@ -20,7 +20,7 @@ import {
   getParticipants,
   joinChannel,
   publish as publish2
-} from "./chunk-OP4JG2BS.js";
+} from "./chunk-5ZQZDDIK.js";
 import {
   readVoluteConfig,
   resolveWakeTriggers,
@@ -33,7 +33,7 @@ import {
 import {
   markIdle,
   onMindEvent
-} from "./chunk-EJVPTVTI.js";
+} from "./chunk-KQSFTPIM.js";
 import {
   extractTextContent,
   getRoutingConfig,
@@ -43,11 +43,13 @@ import {
 } from "./chunk-4JOQZPCE.js";
 import {
   clearMind,
-  getPrompt,
   linkInboundToActiveTurn,
   publish as publish3,
   summarizeOrphanedTurns
-} from "./chunk-UYLGEDVD.js";
+} from "./chunk-YXSUMLTC.js";
+import {
+  getPrompt
+} from "./chunk-4YU7HF4L.js";
 import {
   chownMindDir,
   exec,
@@ -70,11 +72,11 @@ import {
   getUser,
   getUserByUsername,
   syncMindProfile
-} from "./chunk-T6HYVHPG.js";
+} from "./chunk-OV7ZQ2GH.js";
 import {
   publish,
   subscribe
-} from "./chunk-7C44R625.js";
+} from "./chunk-ZNMCCHCP.js";
 import {
   logger_default
 } from "./chunk-T2TP6ZC6.js";
@@ -101,7 +103,7 @@ import {
 } from "./chunk-ZV7MFISX.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 +119,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 +771,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 +934,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-G6TXSDP7.js");
         const sleepMgr = getSleepManagerIfReady2();
         const sleepState = sleepMgr?.getState(name);
         if (sleepState?.sleeping) {
@@ -975,15 +964,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-JINZRG2W.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-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(
         ({ 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 +1030,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-JINZRG2W.js");
       getDeliveryManager2().clearMindSessions(name);
     } catch (err) {
       if (!(err instanceof Error && err.message.includes("not initialized"))) {
@@ -1049,7 +1038,7 @@ var MindManager = class {
       }
     }
     try {
-      const { clearEchoTextCache } = await import("./echo-text-6JJOPUD4.js");
+      const { clearEchoTextCache } = await import("./echo-text-VQPB5L2X.js");
       clearEchoTextCache(name);
     } catch (err) {
       mlog.debug(`failed to clear echo-text cache for ${name}`, logger_default.errorData(err));
@@ -1226,6 +1215,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));
@@ -2306,6 +2299,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 +2339,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 +2404,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 +2756,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) {
@@ -2826,9 +2839,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-CCFAU4GQ.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-CCFAU4GQ.js");
+  const { findDMConversation: findDMConversation2, createConversation: createConversation2 } = await import("./conversations-CJOOCGNW.js");
   const mindUser = await getOrCreateMindUser2(mindName);
   const creatorUser = await getUserByUsername2(creatorUsername);
   if (!creatorUser) {
@@ -2873,7 +2900,8 @@ function defaultState() {
     queuedMessageCount: 0,
     triggerWakeHistory: [],
     wakeFailures: 0,
-    nextWakeAttemptAt: null
+    nextWakeAttemptAt: null,
+    lastWakeAt: null
   };
 }
 function formatCurrentDate() {
@@ -2945,6 +2973,7 @@ var SleepManager = class {
           state2.triggerWakeHistory ??= [];
           state2.wakeFailures ??= 0;
           state2.nextWakeAttemptAt ??= null;
+          state2.lastWakeAt ??= null;
           this.states.set(name, state2);
         }
       }
@@ -2955,7 +2984,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 +3034,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 +3192,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 +3250,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 +3274,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 +3309,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-R7JSQGYX.js");
+    return deliverBatch2(name, payloads);
   }
   // --- Wake failure handling (#419) ---
   /**
@@ -3307,7 +3357,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 +3387,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 +3417,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 +3680,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) => {
@@ -3633,7 +3711,7 @@ 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 { 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 +3850,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) => {
@@ -4030,7 +4106,7 @@ var DeliveryManager = class {
     if (promote.length === 0) return;
     try {
       const db = await getDb();
-      await db.update(deliveryQueue).set({ status: "pending", attempts: 0, next_attempt_at: null }).where(inArray(deliveryQueue.id, promote));
+      await db.update(deliveryQueue).set({ status: "pending", attempts: 0, next_attempt_at: null }).where(inArray2(deliveryQueue.id, promote));
       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));
@@ -4088,6 +4164,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 +4272,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 +4283,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(
@@ -4469,7 +4546,7 @@ var DeliveryManager = class {
       `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.`
     ].filter((line) => line !== null).join("\n");
-    const { sendSystemMessage: sendSystemMessage2 } = await import("./system-chat-XOALE2RD.js");
+    const { sendSystemMessage: sendSystemMessage2 } = await import("./system-chat-NDAW6YP7.js");
     await sendSystemMessage2(mindName, notification);
   }
   /**
@@ -4610,7 +4687,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 +4842,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 +4907,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 +4994,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 +5007,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-G6TXSDP7.js");
     const sm = getSleepManagerIfReady2();
     if (sm?.isSleeping(SPIRIT_NAME)) return true;
   } catch (err) {
@@ -4916,7 +5035,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-G6TXSDP7.js");
     const sm = getSleepManagerIfReady2();
     if (sm) {
       const state2 = sm.getState(mindName);
@@ -5025,6 +5144,7 @@ export {
   wakeMind,
   startSpiritFull,
   stopSpiritFull,
+  buildSeedOrientation,
   stopMindFull,
   matchesGlob,
   SleepManager,
@@ -5036,6 +5156,7 @@ export {
   linkToolResultToTurn,
   resolveSleepAction,
   deliverMessage,
+  deliverBatch,
   ensureSystemChannel,
   joinSystemChannel,
   announceToSystem