volute 0.45.1 → 0.46.0

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

@@ -1,16 +1,16 @@
 #!/usr/bin/env node
 import {
   loadMergedEnv
-} from "./chunk-5GT7URXJ.js";
+} from "./chunk-ZDZISKCL.js";
 import {
   spiritDir
-} from "./chunk-5AUKCNPE.js";
+} from "./chunk-BJZ4PV7R.js";
 import {
   hashSkillDir,
   importSkillFromDir,
   removeSharedSkill,
   sharedSkillsDir
-} from "./chunk-Y6OPHHGM.js";
+} from "./chunk-KGIXX4NM.js";
 import {
   addMessage,
   createChannel,
@@ -20,74 +20,79 @@ import {
   getParticipants,
   joinChannel,
   publish as publish2
-} from "./chunk-JSRMEY52.js";
+} from "./chunk-5ZQZDDIK.js";
 import {
   readVoluteConfig,
+  resolveWakeTriggers,
   writeVoluteConfig
-} from "./chunk-CU6OFXMM.js";
+} from "./chunk-PFZBNKUH.js";
 import {
   isSandboxEnabled,
   wrapForSandbox
-} from "./chunk-OXXTPILE.js";
+} from "./chunk-JZ62SYWR.js";
 import {
   markIdle,
   onMindEvent
-} from "./chunk-HVU45COX.js";
+} from "./chunk-KQSFTPIM.js";
 import {
   extractTextContent,
   getRoutingConfig,
   resolveDeliveryMode,
   resolveRoute,
   setRoutesChangeListener
-} from "./chunk-ZIR7HSAX.js";
+} from "./chunk-4JOQZPCE.js";
 import {
   clearMind,
-  getPrompt,
   linkInboundToActiveTurn,
   publish as publish3,
   summarizeOrphanedTurns
-} from "./chunk-V4GYPD5L.js";
+} from "./chunk-YXSUMLTC.js";
+import {
+  getPrompt
+} from "./chunk-4YU7HF4L.js";
 import {
   chownMindDir,
   exec,
   isIsolationEnabled,
   mindUserName,
   wrapForIsolation
-} from "./chunk-3ERIL673.js";
+} from "./chunk-H2X54EHC.js";
 import {
   aiCompleteUtility,
   getAiConfig,
   resolveApiKey
-} from "./chunk-TSK5PI4L.js";
+} from "./chunk-IHKGWTGT.js";
 import {
   readGlobalConfig,
   writeGlobalConfig
-} from "./chunk-322KE457.js";
+} from "./chunk-F7H6ATM4.js";
 import {
   getOrCreateMindUser,
   getOrCreateSystemUser,
   getUser,
   getUserByUsername,
   syncMindProfile
-} from "./chunk-CYI534DJ.js";
+} from "./chunk-OV7ZQ2GH.js";
 import {
   publish,
   subscribe
-} from "./chunk-ZMIMSIIT.js";
+} from "./chunk-ZNMCCHCP.js";
 import {
   logger_default
 } from "./chunk-T2TP6ZC6.js";
 import {
+  SPIRIT_NAME,
   findMind,
   getBaseName,
   getDb,
+  isSpiritName,
   mindDir,
   mindTmpDir,
   setMindRunning,
   stateDir,
   voluteHome,
   voluteSystemDir
-} from "./chunk-H7IYFRAL.js";
+} from "./chunk-ALKYQULU.js";
 import {
   activity,
   deliveryQueue,
@@ -335,6 +340,9 @@ function revokeMindToken(mindName) {
 function resolveMindToken(token) {
   return tokenToMind.get(token) ?? null;
 }
+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";
@@ -763,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()) {
@@ -939,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-YAHDOIU5.js");
+        const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G6TXSDP7.js");
         const sleepMgr = getSleepManagerIfReady2();
         const sleepState = sleepMgr?.getState(name);
         if (sleepState?.sleeping) {
@@ -969,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-R5STGLXB.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-BGHJE7XA.js").then(({ markIdle: markIdle2 }) => markIdle2(name)).catch((err) => mlog.warn(`failed to mark ${name} idle after crash`, logger_default.errorData(err)));
-      import("./activity-events-OMCSM7XW.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);
@@ -1035,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-R5STGLXB.js");
+      const { getDeliveryManager: getDeliveryManager2 } = await import("./delivery-manager-JINZRG2W.js");
       getDeliveryManager2().clearMindSessions(name);
     } catch (err) {
       if (!(err instanceof Error && err.message.includes("not initialized"))) {
@@ -1043,7 +1038,7 @@ var MindManager = class {
       }
     }
     try {
-      const { clearEchoTextCache } = await import("./echo-text-NQXYYYCU.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));
@@ -1220,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));
@@ -1699,7 +1698,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-XFY3XDD6.js")).default },
+    { id: "pages", load: async () => (await import("./src-OJHARHTF.js")).default },
     { id: "plan", load: async () => (await import("./src-JAOVXO5W.js")).default }
   ];
   const results = [];
@@ -1949,7 +1948,7 @@ async function installNpmExtension(pkg) {
     throw new Error(`Extension "${pkg}" is already installed`);
   }
   const dir = ensureExtensionsNpmDir();
-  const { exec: exec2 } = await import("./exec-4GWHAHS3.js");
+  const { exec: exec2 } = await import("./exec-G3ZRST4Z.js");
   try {
     await exec2("npm", ["install", "--ignore-scripts", pkg], { cwd: dir });
   } catch (err) {
@@ -1970,7 +1969,7 @@ async function uninstallNpmExtension(pkg) {
   packages.splice(idx, 1);
   writeExtensionsConfig(packages);
   try {
-    const { exec: exec2 } = await import("./exec-4GWHAHS3.js");
+    const { exec: exec2 } = await import("./exec-G3ZRST4Z.js");
     await exec2("npm", ["uninstall", "--ignore-scripts", pkg], { cwd: extensionsNpmDir() });
   } catch (err) {
     logger_default.warn(
@@ -2300,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();
@@ -2339,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);
@@ -2384,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 {
@@ -2415,7 +2438,9 @@ ${stderr}` : ""}`;
         return;
       }
       await this.deliverSystem(mindName, `[${schedule.id}] ${text}`, {
-        whileSleeping: schedule.whileSleeping,
+        // Default schedule fires to "queue" while asleep so an unadorned cron
+        // schedule doesn't inherit the DM wake-trigger fallback and wake the mind.
+        whileSleeping: schedule.whileSleeping ?? "queue",
         session: schedule.session
       });
       slog2.info(`fired "${schedule.id}" for ${mindName}`);
@@ -2452,15 +2477,41 @@ ${stderr}` : ""}`;
     }
   }
   async runScript(script, cwd, mindName) {
+    const env = await this.buildScriptEnv(mindName);
     if (isSandboxEnabled()) {
       const dir = this.mindDirs.get(mindName) ?? mindDir(mindName);
       const [cmd, args] = await wrapForSandbox("bash", ["-c", script], dir, mindName, [
         dir,
         mindTmpDir(dir)
       ]);
-      return exec(cmd, args, { cwd });
+      return exec(cmd, args, { cwd, env });
     }
-    return exec("bash", ["-c", script], { cwd, mindName });
+    return exec("bash", ["-c", script], { cwd, mindName, env });
+  }
+  /**
+   * Build the environment for a scheduled script — mirrors the mind process env
+   * (allowlisted base + merged mind env + VOLUTE_* runtime vars), authenticated
+   * with the mind's own per-mind, non-admin token. Reuses the running mind's
+   * token when present; otherwise mints one (stable across fires, regenerated on
+   * next mind start). The daemon admin token is never included.
+   */
+  async buildScriptEnv(mindName) {
+    const dir = this.mindDirs.get(mindName) ?? mindDir(mindName);
+    const entry = await findMind(mindName);
+    const token = getMindToken(mindName) ?? generateMindToken(mindName);
+    const mindLocalBin = resolve5(dir, "home", ".local", "bin");
+    const currentPath = process.env.PATH ?? "";
+    return {
+      ...buildMindBaseEnv(),
+      ...loadMergedEnv(mindName),
+      VOLUTE_MIND: mindName,
+      VOLUTE_STATE_DIR: stateDir(mindName),
+      VOLUTE_MIND_DIR: dir,
+      VOLUTE_MIND_PORT: entry ? String(entry.port) : void 0,
+      VOLUTE_MIND_TOKEN: token,
+      TMPDIR: mindTmpDir(dir),
+      PATH: `${mindLocalBin}:${currentPath}`
+    };
   }
   deliverSystem(mindName, text, opts) {
     return sendSystemMessage(mindName, text, opts);
@@ -2705,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) {
@@ -2771,7 +2818,7 @@ async function wakeMind(name) {
 async function startSpiritFull(name) {
   const entry = await findMind(name);
   if (entry?.dir) {
-    const { registerMindDir } = await import("./delivery-router-6DE3BPHO.js");
+    const { registerMindDir } = await import("./delivery-router-N4A7ZC5T.js");
     registerMindDir(name, entry.dir);
   }
   await getMindManager().startMind(name);
@@ -2792,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-FRZJVQCS.js");
-  const { findDMConversation: findDMConversation2, createConversation: createConversation2 } = await import("./conversations-G4LYMHAA.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) {
@@ -2827,6 +2888,8 @@ async function stopMindFull(name) {
 
 // packages/daemon/src/lib/daemon/sleep-manager.ts
 var slog3 = logger_default.child("sleep");
+var MAX_WAKE_ATTEMPTS = 5;
+var WAKE_BACKOFF_MS = [6e4, 5 * 6e4, 15 * 6e4, 60 * 6e4];
 function defaultState() {
   return {
     sleeping: false,
@@ -2835,7 +2898,10 @@ function defaultState() {
     wokenByTrigger: false,
     voluntaryWakeAt: null,
     queuedMessageCount: 0,
-    triggerWakeHistory: []
+    triggerWakeHistory: [],
+    wakeFailures: 0,
+    nextWakeAttemptAt: null,
+    lastWakeAt: null
   };
 }
 function formatCurrentDate() {
@@ -2905,6 +2971,9 @@ var SleepManager = class {
         const data = JSON.parse(readFileSync7(this.statePath, "utf-8"));
         for (const [name, state2] of Object.entries(data)) {
           state2.triggerWakeHistory ??= [];
+          state2.wakeFailures ??= 0;
+          state2.nextWakeAttemptAt ??= null;
+          state2.lastWakeAt ??= null;
           this.states.set(name, state2);
         }
       }
@@ -2915,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)}
@@ -2965,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) {
@@ -3061,12 +3131,13 @@ var SleepManager = class {
         try {
           await wakeMind(name);
         } catch (err) {
-          slog3.error(`failed to wake ${name}`, logger_default.errorData(err));
+          await this.handleWakeFailure(name, err);
           return;
         }
       }
       const entry = await findMind(name);
       if (!entry) return;
+      this.resetWakeBackoff(name);
       if (opts?.trigger) {
         state2.wokenByTrigger = true;
         state2.triggerWakeHistory.push({
@@ -3121,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) {
@@ -3140,8 +3212,7 @@ var SleepManager = class {
   checkWakeTrigger(name, payload) {
     const config = this.getSleepConfig(name);
     const triggers = config?.wakeTriggers;
-    const mentionsEnabled = triggers?.mentions !== false;
-    const dmsEnabled = triggers?.dms !== false;
+    const { mentions: mentionsEnabled, dms: dmsEnabled } = resolveWakeTriggers(triggers);
     if (dmsEnabled && payload.isDM) return true;
     if (mentionsEnabled && payload.content) {
       const text = typeof payload.content === "string" ? payload.content : Array.isArray(payload.content) ? payload.content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join(" ") : "";
@@ -3179,53 +3250,159 @@ 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;
-      const { deliverMessage: deliverMessage2 } = await import("./message-delivery-IUAXRPFE.js");
-      const delivered = [];
+      const groups = /* @__PURE__ */ new Map();
       for (const row of rows) {
+        let payload;
         try {
-          await deliverMessage2(name, JSON.parse(row.payload));
-          delivered.push(row.id);
+          payload = JSON.parse(row.payload);
         } catch (err) {
-          slog3.warn(`failed to flush queued message ${row.id} for ${name}`, logger_default.errorData(err));
+          slog3.warn(
+            `dropping unparseable queued message ${row.id} for ${name}`,
+            logger_default.errorData(err)
+          );
+          await db.delete(deliveryQueue).where(eq3(deliveryQueue.id, row.id));
+          continue;
         }
+        const channel = payload.channel ?? "unknown";
+        if (!groups.has(channel)) groups.set(channel, []);
+        groups.get(channel)?.push({ id: row.id, payload });
       }
-      if (delivered.length > 0) {
-        await db.delete(deliveryQueue).where(inArray(deliveryQueue.id, delivered));
+      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 ${items.length} queued message(s) on ${channel} for ${name}; leaving them queued`
+          );
+          continue;
+        }
+        await db.delete(deliveryQueue).where(
+          inArray(
+            deliveryQueue.id,
+            items.map((i) => i.id)
+          )
+        );
+        deliveredCount += items.length;
       }
       const state2 = this.states.get(name);
       if (state2) {
-        state2.queuedMessageCount = Math.max(0, state2.queuedMessageCount - delivered.length);
+        state2.queuedMessageCount = Math.max(0, state2.queuedMessageCount - deliveredCount);
       }
-      return delivered.length;
+      return deliveredCount;
     } catch (err) {
       slog3.warn(`failed to flush queued messages for ${name}`, logger_default.errorData(err));
       return 0;
     }
   }
+  /**
+   * 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 deliverQueuedBatch(name, payloads) {
+    const { deliverBatch: deliverBatch2 } = await import("./message-delivery-R7JSQGYX.js");
+    return deliverBatch2(name, payloads);
+  }
+  // --- Wake failure handling (#419) ---
+  /**
+   * Record a failed wake attempt. Applies exponential backoff between retries and,
+   * after MAX_WAKE_ATTEMPTS consecutive failures, gives up and marks the mind errored
+   * rather than retrying every tick forever.
+   */
+  async handleWakeFailure(name, err) {
+    const state2 = this.states.get(name);
+    if (!state2?.sleeping) return;
+    state2.wakeFailures = (state2.wakeFailures ?? 0) + 1;
+    if (state2.wakeFailures >= MAX_WAKE_ATTEMPTS) {
+      await this.markWakeErrored(name, err);
+      return;
+    }
+    const backoff = WAKE_BACKOFF_MS[Math.min(state2.wakeFailures - 1, WAKE_BACKOFF_MS.length - 1)];
+    state2.nextWakeAttemptAt = new Date(Date.now() + backoff).toISOString();
+    this.saveState();
+    slog3.warn(
+      `failed to wake ${name} (attempt ${state2.wakeFailures}/${MAX_WAKE_ATTEMPTS}); retrying in ${Math.round(backoff / 6e4)}m`,
+      logger_default.errorData(err)
+    );
+  }
+  /** Clear wake-failure backoff after a successful wake. */
+  resetWakeBackoff(name) {
+    const state2 = this.states.get(name);
+    if (!state2) return;
+    if (state2.wakeFailures === 0 && state2.nextWakeAttemptAt === null) return;
+    state2.wakeFailures = 0;
+    state2.nextWakeAttemptAt = null;
+    this.saveState();
+  }
+  /**
+   * A mind has failed to wake too many times — it isn't asleep, it's broken.
+   * Clear the sleep state (so the tick stops retrying) and surface the failure
+   * loudly: error log, activity event for the web UI, and a mind notice so the
+   * mind learns what happened on its next successful session. A manual
+   * `volute clock wake` / `volute mind start` is the recovery path.
+   */
+  async markWakeErrored(name, err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    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)
+    );
+    try {
+      await publish({
+        type: "mind_stopped",
+        mind: name,
+        summary: `${name} failed to wake after ${MAX_WAKE_ATTEMPTS} attempts`,
+        metadata: { error: "wake_failed", detail }
+      });
+    } catch (e) {
+      slog3.error(`failed to publish wake-failure activity for ${name}`, logger_default.errorData(e));
+    }
+    await recordNotice({
+      mind: name,
+      session: MIND_LEVEL_SESSION,
+      kind: "startup",
+      reason: "startup_failed",
+      detail: `Wake failed ${MAX_WAKE_ATTEMPTS} times in a row and was given up. Last error: ${detail}`
+    });
+  }
   // --- Internal methods ---
   markSleeping(name, opts) {
     const sleepConfig = this.getSleepConfig(name);
     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: []
+      triggerWakeHistory: [],
+      wakeFailures: 0,
+      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) {
@@ -3240,52 +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.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) {
@@ -3477,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) => {
@@ -3646,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) => {
@@ -3962,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}:`)) {
@@ -4343,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-E65T2HSW.js");
+    const { sendSystemMessage: sendSystemMessage2 } = await import("./system-chat-NDAW6YP7.js");
     await sendSystemMessage2(mindName, notification);
   }
   /**
@@ -4484,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) {
@@ -4517,6 +4724,9 @@ var DeliveryManager = class {
       const buffer = this.batchBuffers.get(bufferKey);
       if (buffer && buffer.messages.length > 0) {
         this.scheduleBatchTimers(mind, session, bufferKey);
+      } else if (session.startsWith("new-")) {
+        mindSessions.delete(session);
+        if (mindSessions.size === 0) this.sessionStates.delete(mind);
       }
     }
   }
@@ -4657,40 +4867,78 @@ function resolveSleepAction(sleepBehavior, wokenByTrigger, wakeTriggerMatches) {
   if (!sleepBehavior && wakeTriggerMatches) return "queue-and-wake";
   return "queue";
 }
-async function deliverMessage(mindName, payload) {
+async function deliverMessage(mindName, payload, opts = {}) {
   try {
     const baseName = await getBaseName(mindName);
     const entry = await findMind(baseName);
     if (!entry) {
       dlog2.warn(`cannot deliver to ${mindName}: mind not found`);
-      return;
+      return false;
     }
-    const textContent = extractTextContent(payload.content);
-    await recordInbound(baseName, payload.channel, payload.sender ?? null, textContent);
-    const sleepManager = getSleepManagerIfReady();
-    if (sleepManager?.isSleeping(baseName)) {
-      const sleepState = sleepManager.getState(baseName);
-      const action = resolveSleepAction(
-        payload.whileSleeping,
-        sleepState.wokenByTrigger,
-        sleepManager.checkWakeTrigger(baseName, payload)
-      );
-      if (action === "skip") {
-        dlog2.info(
-          `skipped delivery to ${baseName} (sleeping, whileSleeping=skip, channel=${payload.channel})`
+    if (!opts.isFlush) {
+      const textContent = extractTextContent(payload.content);
+      await recordInbound(baseName, payload.channel, payload.sender ?? null, textContent);
+      const sleepManager = getSleepManagerIfReady();
+      if (sleepManager?.isSleeping(baseName)) {
+        const sleepState = sleepManager.getState(baseName);
+        const action = resolveSleepAction(
+          payload.whileSleeping,
+          sleepState.wokenByTrigger,
+          sleepManager.checkWakeTrigger(baseName, payload)
         );
-        return;
-      }
-      await sleepManager.queueSleepMessage(baseName, payload);
-      if (action === "queue-and-wake") {
-        sleepManager.initiateWake(baseName, { trigger: { channel: payload.channel } }).catch((err) => dlog2.warn(`failed to trigger-wake ${baseName}`, logger_default.errorData(err)));
+        if (action === "skip") {
+          dlog2.info(
+            `skipped delivery to ${baseName} (sleeping, whileSleeping=skip, channel=${payload.channel})`
+          );
+          return true;
+        }
+        await sleepManager.queueSleepMessage(baseName, payload);
+        if (action === "queue-and-wake") {
+          sleepManager.initiateWake(baseName, { trigger: { channel: payload.channel } }).catch((err) => dlog2.warn(`failed to trigger-wake ${baseName}`, logger_default.errorData(err)));
+        }
+        return true;
       }
-      return;
     }
     const manager = getDeliveryManager();
     await manager.routeAndDeliver(mindName, payload);
+    return true;
   } catch (err) {
     dlog2.warn(`unexpected error delivering to ${mindName}`, logger_default.errorData(err));
+    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;
   }
 }
 
@@ -4700,6 +4948,12 @@ var dmCache = /* @__PURE__ */ new Map();
 function resetSystemDMCache() {
   dmCache.clear();
 }
+function shouldGenerateSystemFallback(opts) {
+  const { senderIsMind, hasMessage, convType, participants, replyTarget } = opts;
+  if (!senderIsMind || !hasMessage) return false;
+  if (isSpiritName(replyTarget)) return false;
+  return convType === "dm" && participants.length === 2 && participants.some((p) => p.userType === "system");
+}
 async function ensureSystemDM(mindName) {
   const cached = dmCache.get(mindName);
   if (cached) return { conversationId: cached };
@@ -4720,7 +4974,7 @@ async function ensureSystemDM(mindName) {
   return { conversationId: conv.id };
 }
 async function sendSystemMessage(mindName, text, opts) {
-  const isSpirit = mindName === "volute";
+  const isSpirit = isSpiritName(mindName);
   let conversationId;
   if (!isSpirit) {
     const dm = await ensureSystemDM(mindName);
@@ -4740,32 +4994,29 @@ 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);
   return { conversationId };
 }
-async function isSpiritAvailable() {
-  const spiritEntry = await findMind("volute");
-  return !!(spiritEntry?.running && spiritEntry.mindType === "spirit");
-}
-async function generateSystemReply(conversationId, mindName, message) {
-  if (await isSpiritAvailable()) {
-    try {
-      await deliverMessage("volute", {
-        content: [{ type: "text", text: message }],
-        channel: `@${mindName}`,
-        conversationId,
-        sender: mindName,
-        isDM: true,
-        participants: ["volute", mindName],
-        participantCount: 2
-      });
-      return;
-    } catch (err) {
-      slog4.warn(`failed to route to spirit, falling back to aiCompleteUtility`, logger_default.errorData(err));
-    }
+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 sm = getSleepManagerIfReady2();
+    if (sm?.isSleeping(SPIRIT_NAME)) return true;
+  } catch (err) {
+    slog4.debug("could not check spirit sleep state", logger_default.errorData(err));
   }
+  return false;
+}
+async function generateSystemFallbackReply(conversationId, mindName, message) {
+  if (await spiritWillHandle()) return;
   const entry = await findMind(mindName);
   const dir = mindDir(mindName);
   const config = readVoluteConfig(dir);
@@ -4784,7 +5035,7 @@ async function generateSystemReply(conversationId, mindName, message) {
     if (config.sleep.schedule?.wake) contextParts.push(`Wake cron: ${config.sleep.schedule.wake}`);
   }
   try {
-    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-YAHDOIU5.js");
+    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G6TXSDP7.js");
     const sm = getSleepManagerIfReady2();
     if (sm) {
       const state2 = sm.getState(mindName);
@@ -4830,10 +5081,11 @@ async function generateSystemReply(conversationId, mindName, message) {
 
 export {
   resetSystemDMCache,
+  shouldGenerateSystemFallback,
   ensureSystemDM,
   sendSystemMessage,
   sendSystemMessageDirect,
-  generateSystemReply,
+  generateSystemFallbackReply,
   checkHealth,
   RotatingLog,
   syncProviderToMinds,
@@ -4892,6 +5144,7 @@ export {
   wakeMind,
   startSpiritFull,
   stopSpiritFull,
+  buildSeedOrientation,
   stopMindFull,
   matchesGlob,
   SleepManager,
@@ -4903,6 +5156,7 @@ export {
   linkToolResultToTurn,
   resolveSleepAction,
   deliverMessage,
+  deliverBatch,
   ensureSystemChannel,
   joinSystemChannel,
   announceToSystem