volute 0.45.1 → 0.45.2

package/dist/{chunk-U4FNXDEJ.js → chunk-YT7PEESJ.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-FR6S2KNN.js";
 import {
   hashSkillDir,
   importSkillFromDir,
   removeSharedSkill,
   sharedSkillsDir
-} from "./chunk-Y6OPHHGM.js";
+} from "./chunk-7ZUB63PS.js";
 import {
   addMessage,
   createChannel,
@@ -20,74 +20,77 @@ import {
   getParticipants,
   joinChannel,
   publish as publish2
-} from "./chunk-JSRMEY52.js";
+} from "./chunk-OP4JG2BS.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-EJVPTVTI.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-UYLGEDVD.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-T6HYVHPG.js";
 import {
   publish,
   subscribe
-} from "./chunk-ZMIMSIIT.js";
+} from "./chunk-7C44R625.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,
@@ -98,7 +101,7 @@ import {
 } from "./chunk-ZV7MFISX.js";
 
 // packages/daemon/src/lib/delivery/message-delivery.ts
-import { and as and5, eq as eq6, inArray as inArray3 } from "drizzle-orm";
+import { and as and5, eq as eq6, inArray as inArray2 } from "drizzle-orm";
 
 // packages/daemon/src/lib/daemon/sleep-manager.ts
 import { execFile as execFile2, spawn as spawnChild } from "child_process";
@@ -114,7 +117,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, inArray } from "drizzle-orm";
+import { and as and2, eq as eq3 } from "drizzle-orm";
 
 // packages/daemon/src/lib/daemon/mind-manager.ts
 import { execFile, spawn } from "child_process";
@@ -335,6 +338,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";
@@ -939,7 +945,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-HCUH4PM4.js");
         const sleepMgr = getSleepManagerIfReady2();
         const sleepState = sleepMgr?.getState(name);
         if (sleepState?.sleeping) {
@@ -969,15 +975,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-VDVKVA46.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-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(
         ({ 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 +1041,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-VDVKVA46.js");
       getDeliveryManager2().clearMindSessions(name);
     } catch (err) {
       if (!(err instanceof Error && err.message.includes("not initialized"))) {
@@ -1043,7 +1049,7 @@ var MindManager = class {
       }
     }
     try {
-      const { clearEchoTextCache } = await import("./echo-text-NQXYYYCU.js");
+      const { clearEchoTextCache } = await import("./echo-text-6JJOPUD4.js");
       clearEchoTextCache(name);
     } catch (err) {
       mlog.debug(`failed to clear echo-text cache for ${name}`, logger_default.errorData(err));
@@ -1699,7 +1705,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 +1955,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 +1976,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(
@@ -2415,7 +2421,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 +2460,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);
@@ -2771,7 +2805,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);
@@ -2793,8 +2827,8 @@ async function stopSpiritFull(name) {
   }).catch((err) => logger_default.error("failed to publish spirit_stopped activity", logger_default.errorData(err)));
 }
 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-FLAEXXZK.js");
+  const { findDMConversation: findDMConversation2, createConversation: createConversation2 } = await import("./conversations-JZTD6KLR.js");
   const mindUser = await getOrCreateMindUser2(mindName);
   const creatorUser = await getUserByUsername2(creatorUsername);
   if (!creatorUser) {
@@ -2827,6 +2861,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 +2871,9 @@ function defaultState() {
     wokenByTrigger: false,
     voluntaryWakeAt: null,
     queuedMessageCount: 0,
-    triggerWakeHistory: []
+    triggerWakeHistory: [],
+    wakeFailures: 0,
+    nextWakeAttemptAt: null
   };
 }
 function formatCurrentDate() {
@@ -2905,6 +2943,8 @@ 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;
           this.states.set(name, state2);
         }
       }
@@ -3061,12 +3101,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({
@@ -3140,8 +3181,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(" ") : "";
@@ -3186,29 +3226,110 @@ var SleepManager = class {
       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 = [];
+      let deliveredCount = 0;
       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;
         }
-      }
-      if (delivered.length > 0) {
-        await db.delete(deliveryQueue).where(inArray(deliveryQueue.id, delivered));
+        const delivered = await this.deliverQueued(name, payload);
+        if (!delivered) {
+          slog3.warn(`failed to flush queued message ${row.id} for ${name}; leaving it queued`);
+          break;
+        }
+        await db.delete(deliveryQueue).where(eq3(deliveryQueue.id, row.id));
+        deliveredCount++;
       }
       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 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.
+   */
+  async deliverQueued(name, payload) {
+    const { deliverMessage: deliverMessage2 } = await import("./message-delivery-3C65ZI6L.js");
+    return deliverMessage2(name, payload, { isFlush: true });
+  }
+  // --- 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.markAwake(name);
+    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);
@@ -3219,7 +3340,9 @@ var SleepManager = class {
       wokenByTrigger: false,
       voluntaryWakeAt: opts?.voluntaryWakeAt ?? null,
       queuedMessageCount: this.states.get(name)?.queuedMessageCount ?? 0,
-      triggerWakeHistory: []
+      triggerWakeHistory: [],
+      wakeFailures: 0,
+      nextWakeAttemptAt: null
     };
     this.states.set(name, state2);
     this.saveState();
@@ -3250,6 +3373,9 @@ var SleepManager = class {
       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) {
@@ -3507,7 +3633,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 as inArray2, sql as sql2 } from "drizzle-orm";
+import { and as and4, eq as eq5, inArray, sql as sql2 } from "drizzle-orm";
 
 // packages/daemon/src/lib/chat/typing.ts
 var DEFAULT_TTL_MS = 1e4;
@@ -3904,7 +4030,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(inArray2(deliveryQueue.id, promote));
+      await db.update(deliveryQueue).set({ status: "pending", attempts: 0, next_attempt_at: null }).where(inArray(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));
@@ -4069,7 +4195,7 @@ var DeliveryManager = class {
     if (valid.length === 0) return;
     try {
       const db = await getDb();
-      await db.delete(deliveryQueue).where(inArray2(deliveryQueue.id, valid));
+      await db.delete(deliveryQueue).where(inArray(deliveryQueue.id, valid));
     } catch (err) {
       dlog.warn("failed to delete delivered delivery queue rows", logger_default.errorData(err));
     }
@@ -4080,7 +4206,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(inArray2(deliveryQueue.id, valid));
+      const rows = await db.select({ id: deliveryQueue.id, attempts: deliveryQueue.attempts }).from(deliveryQueue).where(inArray(deliveryQueue.id, valid));
       for (const row of rows) {
         const attempts = row.attempts + 1;
         const backoffSec = Math.round(
@@ -4343,7 +4469,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-XOALE2RD.js");
     await sendSystemMessage2(mindName, notification);
   }
   /**
@@ -4517,6 +4643,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);
       }
     }
   }
@@ -4632,8 +4761,8 @@ async function linkToolResultToTurn(mind, turnId, toolResultContent, toolUseEven
       await db.update(activity).set({
         turn_id: turnId,
         ...toolUseEventId != null ? { source_event_id: toolUseEventId } : {}
-      }).where(inArray3(activity.id, activityIds));
-      const actRows = await db.select().from(activity).where(inArray3(activity.id, activityIds));
+      }).where(inArray2(activity.id, activityIds));
+      const actRows = await db.select().from(activity).where(inArray2(activity.id, activityIds));
       if (actRows.length > 0) {
         await db.insert(mindHistory).values(
           actRows.map((a) => ({
@@ -4657,40 +4786,44 @@ 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;
   }
 }
 
@@ -4700,6 +4833,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 +4859,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);
@@ -4745,27 +4884,20 @@ async function sendSystemMessageDirect(mindName, 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-HCUH4PM4.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 +4916,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-HCUH4PM4.js");
     const sm = getSleepManagerIfReady2();
     if (sm) {
       const state2 = sm.getState(mindName);
@@ -4830,10 +4962,11 @@ async function generateSystemReply(conversationId, mindName, message) {
 
 export {
   resetSystemDMCache,
+  shouldGenerateSystemFallback,
   ensureSystemDM,
   sendSystemMessage,
   sendSystemMessageDirect,
-  generateSystemReply,
+  generateSystemFallbackReply,
   checkHealth,
   RotatingLog,
   syncProviderToMinds,