volute 0.42.1 → 0.43.0

package/dist/{chunk-6G7R2LPI.js → chunk-PF2AB7VJ.js}

@@ -1,16 +1,16 @@
 #!/usr/bin/env node
 import {
   loadMergedEnv
-} from "./chunk-BLOAJLGI.js";
+} from "./chunk-XDTKJNW5.js";
 import {
   spiritDir
-} from "./chunk-43K5UWF7.js";
+} from "./chunk-65OLHBCL.js";
 import {
   hashSkillDir,
   importSkillFromDir,
   removeSharedSkill,
   sharedSkillsDir
-} from "./chunk-M3T3Y6FT.js";
+} from "./chunk-FSSUANZJ.js";
 import {
   addMessage,
   createChannel,
@@ -20,7 +20,7 @@ import {
   getParticipants,
   joinChannel,
   publish as publish2
-} from "./chunk-YLTIEEVL.js";
+} from "./chunk-K4EHBHPE.js";
 import {
   readVoluteConfig,
   writeVoluteConfig
@@ -28,53 +28,52 @@ import {
 import {
   isSandboxEnabled,
   wrapForSandbox
-} from "./chunk-WR7CSHQ4.js";
+} from "./chunk-C6ESRQZ7.js";
 import {
   markIdle,
   onMindEvent
-} from "./chunk-VBKRZCR7.js";
+} from "./chunk-M3PGGSBH.js";
 import {
   extractTextContent,
   getRoutingConfig,
   resolveDeliveryMode,
-  resolveRoute
-} from "./chunk-62ICA2FF.js";
+  resolveRoute,
+  setRoutesChangeListener
+} from "./chunk-SPLPKBES.js";
 import {
   clearMind,
-  getActiveTurnId,
   getPrompt,
+  linkInboundToActiveTurn,
   publish as publish3,
   summarizeOrphanedTurns
-} from "./chunk-BWZHX46O.js";
-import {
-  exec
-} from "./chunk-GN52E2DP.js";
+} from "./chunk-3WLWKOGM.js";
 import {
   chownMindDir,
+  exec,
   isIsolationEnabled,
   mindUserName,
   wrapForIsolation
-} from "./chunk-TFBQESH7.js";
+} from "./chunk-PGPLCJPK.js";
 import {
   aiCompleteUtility,
   getAiConfig,
   resolveApiKey
-} from "./chunk-4ZSUUBG5.js";
+} from "./chunk-YSV3VJQK.js";
 import {
   readGlobalConfig,
   writeGlobalConfig
-} from "./chunk-KZAL7HEQ.js";
+} from "./chunk-ONM2AZFL.js";
 import {
   getOrCreateMindUser,
   getOrCreateSystemUser,
   getUser,
   getUserByUsername,
   syncMindProfile
-} from "./chunk-5QG36RV7.js";
+} from "./chunk-EFL5UOY4.js";
 import {
   publish,
   subscribe
-} from "./chunk-K547QOCM.js";
+} from "./chunk-7G2EEYXX.js";
 import {
   logger_default
 } from "./chunk-T2TP6ZC6.js";
@@ -88,21 +87,18 @@ import {
   stateDir,
   voluteHome,
   voluteSystemDir
-} from "./chunk-IUZ3EV2D.js";
+} from "./chunk-YAMO2U3N.js";
 import {
   activity,
-  conversationParticipants,
   deliveryQueue,
   messages,
   mindHistory,
   mindNotices,
-  sessions,
-  turns,
-  users
-} from "./chunk-MHFAWJCC.js";
+  sessions
+} from "./chunk-L3IV23ZG.js";
 
 // packages/daemon/src/lib/delivery/message-delivery.ts
-import { and as and4, desc, eq as eq5, inArray as inArray2, sql as sql3 } from "drizzle-orm";
+import { and as and4, eq as eq5, inArray as inArray3 } from "drizzle-orm";
 
 // packages/daemon/src/lib/daemon/sleep-manager.ts
 import { execFile as execFile2, spawn as spawnChild } from "child_process";
@@ -126,6 +122,20 @@ import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as rea
 import { resolve as resolve2 } from "path";
 import { promisify } from "util";
 
+// packages/daemon/src/lib/util/health.ts
+async function checkHealth(port) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/health`, {
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (!res.ok) return { ok: false };
+    const data = await res.json();
+    return { ok: true, name: data.name };
+  } catch {
+    return { ok: false };
+  }
+}
+
 // packages/daemon/src/lib/util/json-state.ts
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from "fs";
 import { writeFile } from "fs/promises";
@@ -236,7 +246,7 @@ var RotatingLog = class extends Writable {
 import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import { resolve } from "path";
 var slog = logger_default.child("cred-sync");
-function writeClaudeCredentials(homeDir, baseName, oauth) {
+async function writeClaudeCredentials(homeDir, baseName, oauth) {
   const claudeDir = resolve(homeDir, ".claude");
   mkdirSync(claudeDir, { recursive: true });
   writeFileSync2(
@@ -252,18 +262,18 @@ function writeClaudeCredentials(homeDir, baseName, oauth) {
     { mode: 384 }
   );
   if (isIsolationEnabled()) {
-    chownMindDir(claudeDir, baseName);
+    await chownMindDir(claudeDir, baseName);
   }
   return claudeDir;
 }
-function writePiProviderKey(piAgentDir, baseName, provider, key) {
+async function writePiProviderKey(piAgentDir, baseName, provider, key) {
   mkdirSync(piAgentDir, { recursive: true });
   const authPath = resolve(piAgentDir, "auth.json");
   const authData = existsSync3(authPath) ? JSON.parse(readFileSync2(authPath, "utf-8")) : {};
   authData[provider] = { type: "api_key", key };
   writeFileSync2(authPath, JSON.stringify(authData, null, 2), { mode: 384 });
   if (isIsolationEnabled()) {
-    chownMindDir(piAgentDir, baseName);
+    await chownMindDir(piAgentDir, baseName);
   }
 }
 function piUsesProvider(piAgentDir, provider) {
@@ -291,11 +301,11 @@ async function syncProviderToMinds(provider, deps = {}) {
       const baseName = entry.parent ?? name;
       const template = entry.template;
       if (template === "claude" || !template) {
-        writeClaudeCredentials(resolve(dir, "home"), baseName, oauth);
+        await writeClaudeCredentials(resolve(dir, "home"), baseName, oauth);
       } else if (template === "pi") {
         const piAgentDir = resolve(dir, ".mind", "pi-agent");
         if (piUsesProvider(piAgentDir, "anthropic")) {
-          writePiProviderKey(piAgentDir, baseName, "anthropic", oauth.access);
+          await writePiProviderKey(piAgentDir, baseName, "anthropic", oauth.access);
         }
       }
     } catch (err) {
@@ -486,6 +496,13 @@ function buildMindBaseEnv(source = process.env) {
   }
   return base;
 }
+var MindStartupError = class extends Error {
+  constructor(message, stderr) {
+    super(message);
+    this.stderr = stderr;
+    this.name = "MindStartupError";
+  }
+};
 function mindPidPath(name) {
   return resolve2(stateDir(name), "mind.pid");
 }
@@ -495,6 +512,26 @@ var MindManager = class {
   shuttingDown = false;
   restartTracker = new RestartTracker();
   pendingContext = /* @__PURE__ */ new Map();
+  // Per-name lifecycle mutex: start/stop/restart for a given mind serialize so
+  // concurrent callers can't double-spawn or have a loser's cleanup delete the
+  // winner's tracked child.
+  locks = /* @__PURE__ */ new Map();
+  /** Run `fn` after any in-flight lifecycle op for `name` settles, serializing per name. */
+  withLock(name, fn) {
+    const prev = this.locks.get(name) ?? Promise.resolve();
+    const result = prev.then(fn, fn);
+    const tail = result.then(
+      () => {
+      },
+      () => {
+      }
+    );
+    this.locks.set(name, tail);
+    tail.finally(() => {
+      if (this.locks.get(name) === tail) this.locks.delete(name);
+    });
+    return result;
+  }
   async resolveTarget(name) {
     const entry = await findMind(name);
     if (!entry) throw new Error(`Unknown mind: ${name}`);
@@ -507,6 +544,9 @@ var MindManager = class {
     return { dir, port: entry.port, baseName: name, template: entry.template };
   }
   async startMind(name) {
+    return this.withLock(name, () => this._startMind(name));
+  }
+  async _startMind(name) {
     if (this.minds.has(name)) {
       throw new Error(`Mind ${name} is already running`);
     }
@@ -540,7 +580,9 @@ var MindManager = class {
       mlog.warn(`failed to read PID file for ${name}`, logger_default.errorData(err));
     }
     try {
-      const res = await fetch(`http://127.0.0.1:${port}/health`);
+      const res = await fetch(`http://127.0.0.1:${port}/health`, {
+        signal: AbortSignal.timeout(2e3)
+      });
       if (res.ok) {
         mlog.warn(`killing orphan process on port ${port}`);
         await killProcessOnPort(port);
@@ -555,8 +597,8 @@ var MindManager = class {
     mkdirSync2(mindTmp, { recursive: true });
     if (isIsolationEnabled()) {
       try {
-        chownMindDir(mindStateDir, baseName);
-        chownMindDir(mindTmp, baseName);
+        await chownMindDir(mindStateDir, baseName);
+        await chownMindDir(mindTmp, baseName);
       } catch (err) {
         throw new Error(
           `Cannot start mind ${name}: failed to set ownership on state directory ${mindStateDir}: ${err instanceof Error ? err.message : err}`
@@ -592,7 +634,7 @@ var MindManager = class {
             const apiKey = await resolveApiKey(provider);
             if (apiKey) {
               const piAgentDir = resolve2(dir, ".mind", "pi-agent");
-              writePiProviderKey(piAgentDir, baseName, provider, apiKey);
+              await writePiProviderKey(piAgentDir, baseName, provider, apiKey);
               env.PI_CODING_AGENT_DIR = piAgentDir;
               const providerEnvVars = {
                 openrouter: "OPENROUTER_API_KEY",
@@ -645,7 +687,7 @@ var MindManager = class {
             writeFileSync3(configTomlPath, 'cli_auth_credentials_store = "file"\n');
           }
           if (isIsolationEnabled()) {
-            chownMindDir(codexDir, baseName);
+            await chownMindDir(codexDir, baseName);
           }
         } else {
           const apiKey = await resolveApiKey("openai-codex");
@@ -675,7 +717,7 @@ var MindManager = class {
           const key = await resolveApiKey("anthropic");
           const oauth = getAiConfig()?.providers.anthropic?.oauth;
           if (key && oauth) {
-            const claudeDir = writeClaudeCredentials(resolve2(dir, "home"), baseName, oauth);
+            const claudeDir = await writeClaudeCredentials(resolve2(dir, "home"), baseName, oauth);
             env.CLAUDE_CONFIG_DIR = claudeDir;
           }
         } else {
@@ -736,29 +778,52 @@ var MindManager = class {
     });
     try {
       await new Promise((resolve9, reject) => {
-        const timeout = setTimeout(() => {
-          reject(new Error(`Mind ${name} did not start within 30s`));
-        }, 3e4);
-        function checkOutput(data) {
-          if (data.toString().match(/listening on :\d+/)) {
-            clearTimeout(timeout);
-            resolve9();
-          }
-        }
-        child.stdout?.on("data", checkOutput);
-        child.stderr?.on("data", checkOutput);
-        child.on("error", (err) => {
-          clearTimeout(timeout);
-          reject(err);
-        });
-        child.on("exit", (code) => {
-          clearTimeout(timeout);
-          const errorLine = recentStderr.find(
-            (l) => l.startsWith("Error:") || l.includes("Error:")
-          );
+        let settled = false;
+        const deadline = Date.now() + 3e4;
+        const onExit = (code) => {
+          const errorLine = recentStderr.find((l) => l.includes("Error:"));
           const detail = errorLine ? `: ${errorLine.trim()}` : "";
-          reject(new Error(`Mind ${name} exited with code ${code} during startup${detail}`));
-        });
+          finish(
+            () => reject(
+              new MindStartupError(
+                `Mind ${name} exited with code ${code} during startup${detail}`,
+                recentStderr.join("\n")
+              )
+            )
+          );
+        };
+        const onError = (err) => finish(() => reject(err));
+        function finish(action) {
+          if (settled) return;
+          settled = true;
+          child.off("exit", onExit);
+          child.off("error", onError);
+          action();
+        }
+        child.on("exit", onExit);
+        child.on("error", onError);
+        const poll = async () => {
+          if (settled) return;
+          const { ok } = await checkHealth(port);
+          if (settled) return;
+          if (ok) {
+            finish(() => resolve9());
+            return;
+          }
+          if (Date.now() >= deadline) {
+            finish(
+              () => reject(
+                new MindStartupError(
+                  `Mind ${name} did not become healthy within 30s`,
+                  recentStderr.join("\n")
+                )
+              )
+            );
+            return;
+          }
+          setTimeout(poll, 250);
+        };
+        void poll();
       });
     } catch (err) {
       this.minds.delete(name);
@@ -826,7 +891,8 @@ var MindManager = class {
           participants: ["volute", name],
           participantCount: 2,
           ...conversationId ? { conversationId } : {}
-        })
+        }),
+        signal: AbortSignal.timeout(1e4)
       });
     } catch (err) {
       mlog.warn(`failed to deliver pending context to ${name}`, logger_default.errorData(err));
@@ -834,14 +900,21 @@ var MindManager = class {
   }
   setupCrashRecovery(name, child) {
     child.on("exit", async (code) => {
+      if (this.minds.get(name)?.child !== child) return;
       this.minds.delete(name);
       if (this.shuttingDown || this.stopping.has(name)) return;
       mlog.error(`mind ${name} exited with code ${code}`);
       try {
-        const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-F5KWIFOX.js");
-        const sleepState = getSleepManagerIfReady2()?.getState(name);
+        const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-BVU5D2AE.js");
+        const sleepMgr = getSleepManagerIfReady2();
+        const sleepState = sleepMgr?.getState(name);
         if (sleepState?.sleeping) {
-          mlog.info(`${name} is sleeping \u2014 skipping crash recovery`);
+          if (sleepState.wokenByTrigger && sleepMgr) {
+            mlog.info(`${name} crashed during trigger wake \u2014 returning to sleep`);
+            void sleepMgr.returnToSleepAfterCrash(name);
+          } else {
+            mlog.info(`${name} is sleeping \u2014 skipping crash recovery`);
+          }
           return;
         }
       } catch (err) {
@@ -862,15 +935,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-J3BRHXUF.js");
+        const { getDeliveryManager: getDeliveryManager2 } = await import("./delivery-manager-5J2BE22P.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-HWVFE533.js").then(({ markIdle: markIdle2 }) => markIdle2(name)).catch((err) => mlog.warn(`failed to mark ${name} idle after crash`, logger_default.errorData(err)));
-      import("./activity-events-KFKVRZE3.js").then(
+      import("./mind-activity-tracker-JHAT6456.js").then(({ markIdle: markIdle2 }) => markIdle2(name)).catch((err) => mlog.warn(`failed to mark ${name} idle after crash`, logger_default.errorData(err)));
+      import("./activity-events-UISXY4Y5.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);
@@ -892,25 +965,32 @@ var MindManager = class {
     });
   }
   async stopMind(name) {
+    return this.withLock(name, () => this._stopMind(name));
+  }
+  async _stopMind(name) {
     const tracked = this.minds.get(name);
     if (!tracked) return;
     this.stopping.add(name);
     const { child } = tracked;
     this.minds.delete(name);
     await new Promise((resolve9) => {
-      child.on("exit", () => resolve9());
-      try {
-        process.kill(-child.pid, "SIGTERM");
-      } catch {
-        resolve9();
-      }
-      setTimeout(() => {
+      const killTimer = setTimeout(() => {
         try {
           process.kill(-child.pid, "SIGKILL");
         } catch {
         }
         resolve9();
       }, 5e3);
+      child.on("exit", () => {
+        clearTimeout(killTimer);
+        resolve9();
+      });
+      try {
+        process.kill(-child.pid, "SIGTERM");
+      } catch {
+        clearTimeout(killTimer);
+        resolve9();
+      }
     });
     this.stopping.delete(name);
     revokeMindToken(name);
@@ -921,7 +1001,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-J3BRHXUF.js");
+      const { getDeliveryManager: getDeliveryManager2 } = await import("./delivery-manager-5J2BE22P.js");
       getDeliveryManager2().clearMindSessions(name);
     } catch (err) {
       if (!(err instanceof Error && err.message.includes("not initialized"))) {
@@ -929,7 +1009,7 @@ var MindManager = class {
       }
     }
     try {
-      const { clearEchoTextCache } = await import("./echo-text-3HBQUWPX.js");
+      const { clearEchoTextCache } = await import("./echo-text-XKBJM6RV.js");
       clearEchoTextCache(name);
     } catch (err) {
       mlog.debug(`failed to clear echo-text cache for ${name}`, logger_default.errorData(err));
@@ -942,8 +1022,10 @@ var MindManager = class {
     mlog.info(`stopped mind ${name}`);
   }
   async restartMind(name) {
-    await this.stopMind(name);
-    await this.startMind(name);
+    return this.withLock(name, async () => {
+      await this._stopMind(name);
+      await this._startMind(name);
+    });
   }
   async stopAll() {
     this.shuttingDown = true;
@@ -1007,6 +1089,9 @@ function getMindManager() {
   if (!instance) throw new Error("MindManager not initialized \u2014 call initMindManager() first");
   return instance;
 }
+function tryGetMindManager() {
+  return instance;
+}
 
 // packages/daemon/src/lib/chat/system-channel.ts
 var SYSTEM_CHANNEL_NAME = "system";
@@ -1803,7 +1888,7 @@ async function installNpmExtension(pkg) {
     throw new Error(`Extension "${pkg}" is already installed`);
   }
   const dir = ensureExtensionsNpmDir();
-  const { exec: exec2 } = await import("./exec-ZDD7NEB4.js");
+  const { exec: exec2 } = await import("./exec-SJK7VUTC.js");
   try {
     await exec2("npm", ["install", "--ignore-scripts", pkg], { cwd: dir });
   } catch (err) {
@@ -1824,7 +1909,7 @@ async function uninstallNpmExtension(pkg) {
   packages.splice(idx, 1);
   writeExtensionsConfig(packages);
   try {
-    const { exec: exec2 } = await import("./exec-ZDD7NEB4.js");
+    const { exec: exec2 } = await import("./exec-SJK7VUTC.js");
     await exec2("npm", ["uninstall", "--ignore-scripts", pkg], { cwd: extensionsNpmDir() });
   } catch (err) {
     logger_default.warn(
@@ -2625,7 +2710,7 @@ async function wakeMind(name) {
 async function startSpiritFull(name) {
   const entry = await findMind(name);
   if (entry?.dir) {
-    const { registerMindDir } = await import("./delivery-router-FDBZJQOY.js");
+    const { registerMindDir } = await import("./delivery-router-HXBHYHJM.js");
     registerMindDir(name, entry.dir);
   }
   await getMindManager().startMind(name);
@@ -2647,8 +2732,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-EAASQPTN.js");
-  const { findDMConversation: findDMConversation2, createConversation: createConversation2 } = await import("./conversations-FSZCUUYO.js");
+  const { getOrCreateMindUser: getOrCreateMindUser2, getUserByUsername: getUserByUsername2 } = await import("./auth-3RIG6GKN.js");
+  const { findDMConversation: findDMConversation2, createConversation: createConversation2 } = await import("./conversations-67WWW25C.js");
   const mindUser = await getOrCreateMindUser2(mindName);
   const creatorUser = await getUserByUsername2(creatorUsername);
   if (!creatorUser) {
@@ -2782,6 +2867,37 @@ var SleepManager = class {
     this.markAwake(name);
     slog3.info(`${name} trigger-wake converted to full wake`);
   }
+  /**
+   * A trigger-woken mind's process crashed while still in the brief trigger-wake
+   * window. The mind-manager crash handler calls this to return it to sleep —
+   * archive the (now-dead) session and restore sleeping state — rather than
+   * leaving it in sleeping+wokenByTrigger limbo. Mirrors the idle-driven
+   * return-to-sleep in onActivityEvent, minus stopping an already-dead process.
+   */
+  async returnToSleepAfterCrash(name) {
+    const state = this.states.get(name);
+    if (!state?.sleeping || !state.wokenByTrigger) return;
+    if (this.transitioning.has(name)) return;
+    this.transitioning.add(name);
+    state.wokenByTrigger = false;
+    try {
+      try {
+        await sleepMind(name);
+      } catch (err) {
+        slog3.warn(`sleepMind during crash-return failed for ${name}`, logger_default.errorData(err));
+      }
+      await this.archiveSessions(name);
+      state.sleeping = true;
+      state.sleepingSince = (/* @__PURE__ */ new Date()).toISOString();
+      state.scheduledWakeAt = this.getNextWakeTime(this.getSleepConfig(name));
+      this.saveState();
+      slog3.info(`${name} returned to sleep after crashing during trigger wake`);
+    } catch (err) {
+      slog3.error(`failed to return ${name} to sleep after crash`, logger_default.errorData(err));
+    } finally {
+      this.transitioning.delete(name);
+    }
+  }
   getSleepConfig(name) {
     if (this.sleepConfigs.has(name)) {
       return this.sleepConfigs.get(name) ?? null;
@@ -2992,7 +3108,7 @@ 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-4ZWFDBAY.js");
+      const { deliverMessage: deliverMessage2 } = await import("./message-delivery-WJBZFALY.js");
       const delivered = [];
       for (const row of rows) {
         try {
@@ -3313,7 +3429,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 and3, eq as eq4, sql as sql2 } from "drizzle-orm";
+import { and as and3, eq as eq4, inArray as inArray2, sql as sql2 } from "drizzle-orm";
 
 // packages/daemon/src/lib/chat/typing.ts
 var DEFAULT_TTL_MS = 1e4;
@@ -3409,12 +3525,41 @@ function publishTypingForChannels(channels, map) {
 // packages/daemon/src/lib/delivery/delivery-manager.ts
 var dlog = logger_default.child("delivery-manager");
 var MAX_BATCH_SIZE = 50;
+var REDRIVE_INTERVAL_MS = 15e3;
+var RETRY_BASE_MS = 5e3;
+var RETRY_MAX_MS = 5 * 6e4;
+var REDRIVE_BATCH_LIMIT = 200;
 var mentionRegexCache = /* @__PURE__ */ new Map();
 var avatarBlocksCache = /* @__PURE__ */ new Map();
 var AVATAR_CACHE_TTL = 5 * 60 * 1e3;
 var DeliveryManager = class {
   sessionStates = /* @__PURE__ */ new Map();
   batchBuffers = /* @__PURE__ */ new Map();
+  /**
+   * delivery_queue row ids currently owned in-memory — either buffered in a batch
+   * buffer or actively being POSTed. The redrive sweep skips these so it never
+   * double-delivers a row that the normal path is already handling.
+   */
+  inFlight = /* @__PURE__ */ new Set();
+  /**
+   * Per-`(baseName:session)` promise chain that serializes POSTs so two rapid
+   * messages to the same session can't be reordered by resolvePort/enrichment latency.
+   */
+  drainChains = /* @__PURE__ */ new Map();
+  redriveTimer = null;
+  /** Predicate for whether a mind is up; overridable in tests. */
+  isMindRunning = (name) => tryGetMindManager()?.isRunning(name) ?? false;
+  constructor() {
+    setRoutesChangeListener((mind) => {
+      this.releaseGated(mind).catch(
+        (err) => dlog.warn(`failed to release gated messages for ${mind}`, logger_default.errorData(err))
+      );
+    });
+  }
+  /** Test seam: override the mind-running predicate. */
+  setRunningCheck(fn) {
+    this.isMindRunning = fn;
+  }
   // --- Public API ---
   /**
    * Route and deliver a message to a mind. This is the main entry point.
@@ -3434,7 +3579,8 @@ var DeliveryManager = class {
         await this.enqueueBatch(mindName, sessionName2, payload, sessionConfig2);
         return { routed: true, session: sessionName2, destination: "mind", mode: "batch" };
       }
-      await this.deliverToMind(mindName, sessionName2, payload, sessionConfig2);
+      const queueId2 = await this.persistToQueue(mindName, sessionName2, payload);
+      await this.deliverToMind(mindName, sessionName2, payload, sessionConfig2, queueId2);
       return { routed: true, session: sessionName2, destination: "mind", mode: "immediate" };
     }
     const meta = {
@@ -3472,16 +3618,14 @@ var DeliveryManager = class {
     if (sessionName === "$new") {
       sessionName = `new-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     }
-    tagRecentInbound(baseName, sessionName, payload.channel).catch((err) => {
-      dlog.warn(`tagRecentInbound failed for ${baseName}`, logger_default.errorData(err));
-    });
     const sessionConfig = resolveDeliveryMode(config, sessionName, route.rule);
     if (sessionConfig.delivery.mode === "batch") {
       dlog.debug(`enqueueing batch message for ${mindName}/${sessionName}`);
       await this.enqueueBatch(mindName, sessionName, payload, sessionConfig);
       return { routed: true, session: sessionName, destination: "mind", mode: "batch" };
     }
-    await this.deliverToMind(mindName, sessionName, payload, sessionConfig);
+    const queueId = await this.persistToQueue(mindName, sessionName, payload);
+    await this.deliverToMind(mindName, sessionName, payload, sessionConfig, queueId);
     return { routed: true, session: sessionName, destination: "mind", mode: "immediate" };
   }
   /**
@@ -3506,44 +3650,121 @@ var DeliveryManager = class {
     }
   }
   /**
-   * Restore queued messages from DB on daemon restart.
+   * Restore queued messages from DB on daemon restart — a single redrive pass.
+   * All accepted deliveries are persisted to delivery_queue before their POST and
+   * only deleted on mind-ack, so pending rows are exactly the undelivered messages.
    */
   async restoreFromDb() {
+    await this.redrive();
+  }
+  /** Start the periodic redrive sweep (idempotent). */
+  startRedrive() {
+    if (this.redriveTimer) return;
+    this.redriveTimer = setInterval(() => {
+      this.redrive().catch((err) => dlog.warn("redrive sweep failed", logger_default.errorData(err)));
+    }, REDRIVE_INTERVAL_MS);
+    this.redriveTimer.unref();
+  }
+  /**
+   * Re-read pending delivery_queue rows that are eligible (past their backoff window)
+   * and re-deliver them through the normal path. Rows already owned in-memory
+   * (`inFlight`) and minds that are down are skipped so we never hot-loop or double-send.
+   */
+  async redrive() {
+    let rows;
     try {
       const db = await getDb();
-      const rows = await db.select().from(deliveryQueue).where(eq4(deliveryQueue.status, "pending"));
-      for (const row of rows) {
-        let payload;
-        try {
-          payload = JSON.parse(row.payload);
-        } catch (parseErr) {
-          dlog.warn(
-            `corrupt payload in delivery queue row ${row.id}, skipping`,
-            logger_default.errorData(parseErr)
-          );
-          continue;
-        }
-        const config = getRoutingConfig(row.mind);
-        const sessionConfig = resolveDeliveryMode(config, row.session);
-        if (sessionConfig.delivery.mode === "batch") {
-          this.addToBatchBuffer(row.mind, row.session, payload, sessionConfig);
-        } else {
-          try {
-            await db.delete(deliveryQueue).where(eq4(deliveryQueue.id, row.id));
-          } catch (err) {
-            dlog.warn(`failed to delete queue row ${row.id} for ${row.mind}`, logger_default.errorData(err));
-          }
-          this.deliverToMind(row.mind, row.session, payload, sessionConfig).catch((err) => {
-            dlog.warn(`failed to restore delivery for ${row.mind}`, logger_default.errorData(err));
-          });
-        }
+      rows = await db.select().from(deliveryQueue).where(
+        and3(
+          eq4(deliveryQueue.status, "pending"),
+          sql2`(${deliveryQueue.next_attempt_at} IS NULL OR ${deliveryQueue.next_attempt_at} <= datetime('now'))`
+        )
+      ).orderBy(deliveryQueue.id).limit(REDRIVE_BATCH_LIMIT);
+    } catch (err) {
+      dlog.warn("failed to read delivery queue for redrive", logger_default.errorData(err));
+      return;
+    }
+    let redriven = 0;
+    for (const row of rows) {
+      if (this.inFlight.has(row.id)) continue;
+      if (!this.isMindRunning(row.mind)) continue;
+      let payload;
+      try {
+        payload = JSON.parse(row.payload);
+      } catch (parseErr) {
+        dlog.warn(
+          `corrupt payload in delivery queue row ${row.id}, dropping`,
+          logger_default.errorData(parseErr)
+        );
+        await this.deleteQueueRows([row.id]);
+        continue;
+      }
+      const config = getRoutingConfig(row.mind);
+      const sessionConfig = resolveDeliveryMode(config, row.session);
+      const target = row.target_mind ?? row.mind;
+      if (sessionConfig.delivery.mode === "batch") {
+        this.inFlight.add(row.id);
+        this.addToBatchBuffer(target, row.session, sessionConfig, {
+          payload,
+          channel: payload.channel,
+          sender: payload.sender ?? null,
+          createdAt: Date.now(),
+          queueId: row.id
+        });
+      } else {
+        this.deliverToMind(target, row.session, payload, sessionConfig, row.id).catch((err) => {
+          dlog.warn(`failed to redrive delivery for ${target}`, logger_default.errorData(err));
+        });
+      }
+      redriven++;
+    }
+    if (redriven > 0) dlog.info(`redrove ${redriven} pending delivery queue rows`);
+  }
+  /**
+   * Re-evaluate a mind's `gated` rows against its current routes.json and promote any
+   * that now match to `pending` (delivered by the next redrive sweep). Called when the
+   * routing config changes.
+   */
+  async releaseGated(mindName) {
+    const baseName = await getBaseName(mindName);
+    const config = getRoutingConfig(baseName);
+    let rows;
+    try {
+      const db = await getDb();
+      rows = await db.select().from(deliveryQueue).where(and3(eq4(deliveryQueue.mind, baseName), eq4(deliveryQueue.status, "gated")));
+    } catch (err) {
+      dlog.warn(`failed to read gated rows for ${baseName}`, logger_default.errorData(err));
+      return;
+    }
+    const promote = [];
+    for (const row of rows) {
+      let payload;
+      try {
+        payload = JSON.parse(row.payload);
+      } catch {
+        continue;
       }
-      if (rows.length > 0) {
-        dlog.info(`restored ${rows.length} queued messages from DB`);
+      const meta = {
+        channel: payload.channel,
+        sender: payload.sender ?? void 0,
+        isDM: payload.isDM,
+        participantCount: payload.participantCount
+      };
+      const route = resolveRoute(config, meta);
+      if (route.matched && route.destination === "mind") {
+        promote.push(row.id);
       }
+    }
+    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));
+      dlog.info(`released ${promote.length} gated message(s) for ${baseName} after route change`);
     } catch (err) {
-      dlog.warn("failed to restore delivery queue from DB", logger_default.errorData(err));
+      dlog.warn(`failed to promote gated rows for ${baseName}`, logger_default.errorData(err));
+      return;
     }
+    await this.redrive();
   }
   /**
    * Get pending (gated) messages for a mind.
@@ -3600,6 +3821,9 @@ var DeliveryManager = class {
       if (bufferKey.startsWith(`${mindName}:`)) {
         if (buffer.debounceTimer) clearTimeout(buffer.debounceTimer);
         if (buffer.maxWaitTimer) clearTimeout(buffer.maxWaitTimer);
+        for (const msg of buffer.messages) {
+          if (msg.queueId != null) this.inFlight.delete(msg.queueId);
+        }
         toDelete.push(bufferKey);
       }
     }
@@ -3636,6 +3860,13 @@ var DeliveryManager = class {
     }
     this.batchBuffers.clear();
     this.sessionStates.clear();
+    this.inFlight.clear();
+    this.drainChains.clear();
+    if (this.redriveTimer) {
+      clearInterval(this.redriveTimer);
+      this.redriveTimer = null;
+    }
+    setRoutesChangeListener(void 0);
     if (instance7 === this) instance7 = void 0;
   }
   // --- Private ---
@@ -3667,162 +3898,213 @@ var DeliveryManager = class {
       clearTimeout(timeout);
     }
   }
-  async deliverToMind(mindName, session, payload, sessionConfig) {
-    const resolved = await this.resolvePort(mindName);
-    if (!resolved) {
-      dlog.warn(`cannot deliver to ${mindName}: mind not found`);
-      return;
-    }
-    const { baseName, port } = resolved;
-    const senders = /* @__PURE__ */ new Set();
-    if (payload.sender) senders.add(payload.sender);
-    const channels = /* @__PURE__ */ new Set();
-    if (payload.channel) channels.add(payload.channel);
-    this.incrementActive(baseName, session, senders, channels);
-    const typingMap = getTypingMap();
-    if (payload.channel) {
-      typingMap.set(payload.channel, baseName, { persistent: true });
-    }
-    if (payload.conversationId) {
-      typingMap.set(payload.conversationId, baseName, { persistent: true });
-    }
-    onMindEvent(baseName, "delivery", payload.channel);
-    const enrichedPayload = await this.enrichWithProfiles(baseName, session, payload);
-    const body = JSON.stringify({
-      ...enrichedPayload,
-      session,
-      interrupt: sessionConfig.interrupt,
-      instructions: sessionConfig.instructions
+  /**
+   * Serialize `fn` on a per-key promise chain so calls for the same key run one at a
+   * time in submission order. Used to drain a `(mind, session)` sequentially.
+   */
+  runSequential(key, fn) {
+    const prev = this.drainChains.get(key) ?? Promise.resolve();
+    const run = prev.then(fn, fn);
+    const tail = run.then(
+      () => {
+      },
+      () => {
+      }
+    );
+    this.drainChains.set(key, tail);
+    tail.then(() => {
+      if (this.drainChains.get(key) === tail) this.drainChains.delete(key);
     });
+    return run;
+  }
+  /** Delete delivered queue rows by their specific ids. */
+  async deleteQueueRows(ids) {
+    const valid = [...new Set(ids.filter((id) => typeof id === "number"))];
+    if (valid.length === 0) return;
     try {
-      const ok = await this.postToMind(port, body);
-      if (!ok) {
-        this.decrementActive(baseName, session);
-        publishTypingForChannels(typingMap.deleteSender(baseName), typingMap);
-      }
+      const db = await getDb();
+      await db.delete(deliveryQueue).where(inArray2(deliveryQueue.id, valid));
     } catch (err) {
-      dlog.warn(`failed to deliver to ${mindName}`, logger_default.errorData(err));
-      this.decrementActive(baseName, session);
-      publishTypingForChannels(typingMap.deleteSender(baseName), typingMap);
+      dlog.warn("failed to delete delivered delivery queue rows", logger_default.errorData(err));
     }
   }
-  async deliverBatchToMind(mindName, session, messages2, sessionConfig, interruptOverride) {
-    const resolved = await this.resolvePort(mindName);
-    if (!resolved) {
-      dlog.warn(`cannot deliver batch to ${mindName}: mind not found`);
-      return;
-    }
-    const { baseName, port } = resolved;
-    const firstPerChannel = /* @__PURE__ */ new Set();
-    const isFirstForChannel = [];
-    for (const msg of messages2) {
-      const ch = msg.channel ?? "unknown";
-      isFirstForChannel.push(!firstPerChannel.has(ch));
-      firstPerChannel.add(ch);
-    }
-    const enrichedMessages = await Promise.all(
-      messages2.map(async (msg, i) => {
-        if (!isFirstForChannel[i]) return msg;
-        const enrichedPayload = await this.enrichWithProfiles(baseName, session, msg.payload);
-        return { ...msg, payload: enrichedPayload };
-      })
-    );
-    const channels = {};
-    for (const msg of enrichedMessages) {
-      const ch = msg.channel ?? "unknown";
-      if (!channels[ch]) channels[ch] = [];
-      channels[ch].push(msg.payload);
-    }
-    const senders = /* @__PURE__ */ new Set();
-    const channelSet = /* @__PURE__ */ new Set();
-    for (const msg of messages2) {
-      if (msg.sender) senders.add(msg.sender);
-      if (msg.channel) channelSet.add(msg.channel);
-    }
-    this.incrementActive(baseName, session, senders, channelSet);
-    const typingMap = getTypingMap();
-    for (const ch of Object.keys(channels)) {
-      if (ch !== "unknown") typingMap.set(ch, baseName, { persistent: true });
-    }
-    const seenConvIds = /* @__PURE__ */ new Set();
-    for (const msg of messages2) {
-      if (msg.payload.conversationId && !seenConvIds.has(msg.payload.conversationId)) {
-        seenConvIds.add(msg.payload.conversationId);
-        typingMap.set(msg.payload.conversationId, baseName, { persistent: true });
+  /** Bump attempt counters and set a backoff window so a down mind isn't hot-looped. */
+  async scheduleRetry(ids) {
+    const valid = [...new Set(ids.filter((id) => typeof id === "number"))];
+    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));
+      for (const row of rows) {
+        const attempts = row.attempts + 1;
+        const backoffSec = Math.round(
+          Math.min(RETRY_MAX_MS, RETRY_BASE_MS * 2 ** Math.min(attempts, 20)) / 1e3
+        );
+        await db.update(deliveryQueue).set({ attempts, next_attempt_at: sql2`datetime('now', ${`+${backoffSec} seconds`})` }).where(eq4(deliveryQueue.id, row.id));
       }
+    } catch (err) {
+      dlog.warn("failed to schedule delivery retry", logger_default.errorData(err));
     }
-    const body = JSON.stringify({
-      session,
-      batch: { channels },
-      interrupt: interruptOverride ?? sessionConfig.interrupt,
-      instructions: sessionConfig.instructions
-    });
-    try {
-      const ok = await this.postToMind(port, body);
-      if (!ok) {
+  }
+  async deliverToMind(mindName, session, payload, sessionConfig, queueId) {
+    if (queueId != null) this.inFlight.add(queueId);
+    await this.runSequential(`${mindName}:${session}`, async () => {
+      const resolved = await this.resolvePort(mindName);
+      if (!resolved) {
+        dlog.warn(`cannot deliver to ${mindName}: mind not found`);
+        if (queueId != null) this.inFlight.delete(queueId);
+        return;
+      }
+      const { baseName, port } = resolved;
+      const senders = /* @__PURE__ */ new Set();
+      if (payload.sender) senders.add(payload.sender);
+      const channels = /* @__PURE__ */ new Set();
+      if (payload.channel) channels.add(payload.channel);
+      this.incrementActive(baseName, session, senders, channels);
+      linkInboundToActiveTurn(baseName, session, payload.channel).catch(
+        (err) => dlog.warn(`failed to link mid-turn inbound for ${baseName}`, logger_default.errorData(err))
+      );
+      const typingMap = getTypingMap();
+      if (payload.channel) {
+        typingMap.set(payload.channel, baseName, { persistent: true });
+      }
+      if (payload.conversationId) {
+        typingMap.set(payload.conversationId, baseName, { persistent: true });
+      }
+      onMindEvent(baseName, "delivery", payload.channel);
+      const enrichedPayload = await this.enrichWithProfiles(baseName, session, payload);
+      const body = JSON.stringify({
+        ...enrichedPayload,
+        session,
+        interrupt: sessionConfig.interrupt,
+        instructions: sessionConfig.instructions
+      });
+      try {
+        const ok = await this.postToMind(port, body);
+        if (!ok) {
+          this.decrementActive(baseName, session);
+          publishTypingForChannels(typingMap.deleteSender(baseName), typingMap);
+          await this.scheduleRetry([queueId]);
+        } else {
+          await this.deleteQueueRows([queueId]);
+        }
+      } catch (err) {
+        dlog.warn(`failed to deliver to ${mindName}`, logger_default.errorData(err));
         this.decrementActive(baseName, session);
         publishTypingForChannels(typingMap.deleteSender(baseName), typingMap);
-      } else {
-        try {
-          const db = await getDb();
-          await db.delete(deliveryQueue).where(
-            and3(
-              eq4(deliveryQueue.mind, baseName),
-              eq4(deliveryQueue.session, session),
-              eq4(deliveryQueue.status, "pending")
-            )
-          );
-        } catch (err) {
-          dlog.warn(
-            `failed to clean delivery queue for ${baseName}/${session}`,
-            logger_default.errorData(err)
-          );
+        await this.scheduleRetry([queueId]);
+      } finally {
+        if (queueId != null) this.inFlight.delete(queueId);
+      }
+    });
+  }
+  async deliverBatchToMind(mindName, session, messages2, sessionConfig, interruptOverride) {
+    const queueIds = messages2.map((m) => m.queueId).filter((id) => typeof id === "number");
+    await this.runSequential(`${mindName}:${session}`, async () => {
+      const resolved = await this.resolvePort(mindName);
+      if (!resolved) {
+        dlog.warn(`cannot deliver batch to ${mindName}: mind not found`);
+        for (const id of queueIds) this.inFlight.delete(id);
+        return;
+      }
+      const { baseName, port } = resolved;
+      const firstPerChannel = /* @__PURE__ */ new Set();
+      const isFirstForChannel = [];
+      for (const msg of messages2) {
+        const ch = msg.channel ?? "unknown";
+        isFirstForChannel.push(!firstPerChannel.has(ch));
+        firstPerChannel.add(ch);
+      }
+      const enrichedMessages = await Promise.all(
+        messages2.map(async (msg, i) => {
+          if (!isFirstForChannel[i]) return msg;
+          const enrichedPayload = await this.enrichWithProfiles(baseName, session, msg.payload);
+          return { ...msg, payload: enrichedPayload };
+        })
+      );
+      const channels = {};
+      for (const msg of enrichedMessages) {
+        const ch = msg.channel ?? "unknown";
+        if (!channels[ch]) channels[ch] = [];
+        channels[ch].push(msg.payload);
+      }
+      const senders = /* @__PURE__ */ new Set();
+      const channelSet = /* @__PURE__ */ new Set();
+      for (const msg of messages2) {
+        if (msg.sender) senders.add(msg.sender);
+        if (msg.channel) channelSet.add(msg.channel);
+      }
+      this.incrementActive(baseName, session, senders, channelSet);
+      for (const ch of channelSet) {
+        linkInboundToActiveTurn(baseName, session, ch).catch(
+          (err) => dlog.warn(`failed to link mid-turn inbound for ${baseName}`, logger_default.errorData(err))
+        );
+      }
+      const typingMap = getTypingMap();
+      for (const ch of Object.keys(channels)) {
+        if (ch !== "unknown") typingMap.set(ch, baseName, { persistent: true });
+      }
+      const seenConvIds = /* @__PURE__ */ new Set();
+      for (const msg of messages2) {
+        if (msg.payload.conversationId && !seenConvIds.has(msg.payload.conversationId)) {
+          seenConvIds.add(msg.payload.conversationId);
+          typingMap.set(msg.payload.conversationId, baseName, { persistent: true });
         }
       }
-    } catch (err) {
-      dlog.warn(`failed to deliver batch to ${mindName}`, logger_default.errorData(err));
-      this.decrementActive(baseName, session);
-      publishTypingForChannels(typingMap.deleteSender(baseName), typingMap);
-    }
+      const body = JSON.stringify({
+        session,
+        batch: { channels },
+        interrupt: interruptOverride ?? sessionConfig.interrupt,
+        instructions: sessionConfig.instructions
+      });
+      try {
+        const ok = await this.postToMind(port, body);
+        if (!ok) {
+          this.decrementActive(baseName, session);
+          publishTypingForChannels(typingMap.deleteSender(baseName), typingMap);
+          await this.scheduleRetry(queueIds);
+        } else {
+          await this.deleteQueueRows(queueIds);
+        }
+      } catch (err) {
+        dlog.warn(`failed to deliver batch to ${mindName}`, logger_default.errorData(err));
+        this.decrementActive(baseName, session);
+        publishTypingForChannels(typingMap.deleteSender(baseName), typingMap);
+        await this.scheduleRetry(queueIds);
+      } finally {
+        for (const id of queueIds) this.inFlight.delete(id);
+      }
+    });
   }
   async enqueueBatch(mindName, session, payload, sessionConfig) {
     const delivery = sessionConfig.delivery;
+    const baseName = await getBaseName(mindName);
+    const queueId = await this.persistToQueue(mindName, session, payload);
+    if (queueId != null) this.inFlight.add(queueId);
+    const msg = {
+      payload,
+      channel: payload.channel,
+      sender: payload.sender ?? null,
+      createdAt: Date.now(),
+      queueId
+    };
     if (delivery.triggers?.length) {
       const text = extractTextContent(payload.content);
       const lower = text.toLowerCase();
       if (delivery.triggers.some((t) => lower.includes(t.toLowerCase()))) {
-        await this.flushBatch(mindName, session, [
-          {
-            payload,
-            channel: payload.channel,
-            sender: payload.sender ?? null,
-            createdAt: Date.now()
-          }
-        ]);
+        await this.flushBatch(mindName, session, [msg]);
         return;
       }
     }
-    const baseName = await getBaseName(mindName);
     const state = this.sessionStates.get(baseName)?.get(session);
     if (state && state.activeCount > 0 && payload.sender && !state.lastDeliverySenders.has(payload.sender) && payload.channel && state.lastDeliveryChannels.has(payload.channel) && Date.now() - state.lastDeliveredAt < delivery.maxWait * 1e3 && Date.now() - state.lastInterruptAt > delivery.debounce * 1e3) {
       state.lastInterruptAt = Date.now();
-      this.persistToQueue(mindName, session, payload).catch((err) => {
-        dlog.warn(`failed to persist batch message for ${mindName}/${session}`, logger_default.errorData(err));
-      });
-      await this.flushBatch(
-        mindName,
-        session,
-        [{ payload, channel: payload.channel, sender: payload.sender, createdAt: Date.now() }],
-        true
-      );
+      await this.flushBatch(mindName, session, [msg], true);
       return;
     }
-    this.persistToQueue(mindName, session, payload).catch((err) => {
-      dlog.warn(`failed to persist batch message for ${mindName}/${session}`, logger_default.errorData(err));
-    });
-    this.addToBatchBuffer(mindName, session, payload, sessionConfig);
+    this.addToBatchBuffer(mindName, session, sessionConfig, msg);
   }
-  addToBatchBuffer(mindName, session, payload, sessionConfig) {
+  addToBatchBuffer(mindName, session, sessionConfig, msg) {
     const delivery = sessionConfig.delivery;
     const bufferKey = `${mindName}:${session}`;
     let buffer = this.batchBuffers.get(bufferKey);
@@ -3835,12 +4117,7 @@ var DeliveryManager = class {
       };
       this.batchBuffers.set(bufferKey, buffer);
     }
-    buffer.messages.push({
-      payload,
-      channel: payload.channel,
-      sender: payload.sender ?? null,
-      createdAt: Date.now()
-    });
+    buffer.messages.push(msg);
     if (buffer.messages.length >= MAX_BATCH_SIZE) {
       this.flushBatch(mindName, session);
       return;
@@ -3892,7 +4169,7 @@ var DeliveryManager = class {
   }
   async gateMessage(mindName, session, payload) {
     const baseName = await getBaseName(mindName);
-    await this.persistToQueue(baseName, session, payload, "gated");
+    await this.persistToQueue(mindName, session, payload, "gated");
     try {
       const db = await getDb();
       const count = await db.select({ count: sql2`count(*)` }).from(deliveryQueue).where(
@@ -3924,25 +4201,37 @@ var DeliveryManager = class {
       `To accept this channel, add a routing rule for "${channel}" to your routes.json.`,
       `Messages are being held until a route is configured.`
     ].filter((line) => line !== null).join("\n");
-    const { sendSystemMessage: sendSystemMessage2 } = await import("./system-chat-EQIH6JVL.js");
+    const { sendSystemMessage: sendSystemMessage2 } = await import("./system-chat-KMQIP7VH.js");
     await sendSystemMessage2(mindName, notification);
   }
+  /**
+   * Insert a delivery_queue row and return its id. The `mind` column is always keyed by
+   * `baseName` so inserts under a variant name and the id-scoped cleanup use the same key
+   * (fixes the variant mismatch where variant-keyed rows were never matched by the base
+   * cleanup). `target_mind` records the original delivery target (`mindName`, which may be a
+   * variant) so redrive resolves the port from it — a variant's stranded row is re-delivered
+   * to the variant, not the parent.
+   */
   async persistToQueue(mindName, session, payload, status = "pending") {
     try {
+      const baseName = await getBaseName(mindName);
       const db = await getDb();
-      await db.insert(deliveryQueue).values({
-        mind: mindName,
+      const result = await db.insert(deliveryQueue).values({
+        mind: baseName,
+        target_mind: mindName,
         session,
         channel: payload.channel ?? null,
         sender: payload.sender ?? null,
         status,
         payload: JSON.stringify(payload)
-      });
+      }).returning({ id: deliveryQueue.id });
+      return result[0]?.id;
     } catch (err) {
       dlog.warn(
         `failed to persist to delivery queue for ${mindName}/${session}`,
         logger_default.errorData(err)
       );
+      return void 0;
     }
   }
   async enrichWithProfiles(mindName, session, payload) {
@@ -4162,27 +4451,33 @@ async function linkToolResultToTurn(mind, turnId, toolResultContent, toolUseEven
         id: mindHistory.id,
         channel: mindHistory.channel,
         content: mindHistory.content,
-        message_id: mindHistory.message_id
+        message_id: mindHistory.message_id,
+        turn_id: mindHistory.turn_id
       }).from(mindHistory).where(and4(eq5(mindHistory.id, outboundId), eq5(mindHistory.mind, mind))).limit(1);
       const row = rows[0];
       if (!row) {
         dlog2.warn(`outbound marker references missing record: mind=${mind} id=${outboundId}`);
         continue;
       }
-      await db.update(mindHistory).set({ turn_id: turnId }).where(eq5(mindHistory.id, outboundId));
+      const alreadyTagged = row.turn_id != null;
+      if (!alreadyTagged) {
+        await db.update(mindHistory).set({ turn_id: turnId }).where(eq5(mindHistory.id, outboundId));
+      }
       if (row.message_id) {
         await db.update(messages).set({
           turn_id: turnId,
           ...toolUseEventId != null ? { source_event_id: toolUseEventId } : {}
         }).where(eq5(messages.id, Number(row.message_id)));
       }
-      publish3(mind, {
-        mind,
-        type: "outbound",
-        channel: row.channel ?? void 0,
-        content: row.content ?? void 0,
-        turnId
-      });
+      if (!alreadyTagged) {
+        publish3(mind, {
+          mind,
+          type: "outbound",
+          channel: row.channel ?? void 0,
+          content: row.content ?? void 0,
+          turnId
+        });
+      }
     } catch (err) {
       dlog2.warn(`failed to link outbound ${outboundId} to turn ${turnId}`, logger_default.errorData(err));
     }
@@ -4196,8 +4491,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) => ({
@@ -4215,108 +4510,6 @@ async function linkToolResultToTurn(mind, turnId, toolResultContent, toolUseEven
     }
   }
 }
-async function tagUntaggedOutbound(mind, turnId) {
-  const db = await getDb();
-  const range = await db.select({
-    minId: sql3`MIN(${mindHistory.id})`,
-    maxId: sql3`MAX(${mindHistory.id})`
-  }).from(mindHistory).where(and4(eq5(mindHistory.mind, mind), eq5(mindHistory.turn_id, turnId)));
-  const minId = range[0]?.minId;
-  const maxId = range[0]?.maxId;
-  if (minId == null || maxId == null) return;
-  const orphans = await db.select({ id: mindHistory.id, message_id: mindHistory.message_id }).from(mindHistory).where(
-    and4(
-      eq5(mindHistory.mind, mind),
-      eq5(mindHistory.type, "outbound"),
-      sql3`${mindHistory.turn_id} IS NULL`,
-      sql3`${mindHistory.id} >= ${minId}`,
-      sql3`${mindHistory.id} <= ${maxId}`
-    )
-  );
-  if (orphans.length === 0) return;
-  const orphanIds = orphans.map((r) => r.id);
-  await db.update(mindHistory).set({ turn_id: turnId }).where(inArray2(mindHistory.id, orphanIds));
-  const orphansWithMessages = orphans.filter((o) => o.message_id);
-  if (orphansWithMessages.length > 0) {
-    const toolUseEvents = await db.select({ id: mindHistory.id }).from(mindHistory).where(
-      and4(
-        eq5(mindHistory.mind, mind),
-        eq5(mindHistory.turn_id, turnId),
-        eq5(mindHistory.type, "tool_use")
-      )
-    ).orderBy(mindHistory.id);
-    for (const orphan of orphansWithMessages) {
-      let sourceEventId = null;
-      for (let i = toolUseEvents.length - 1; i >= 0; i--) {
-        if (toolUseEvents[i].id < orphan.id) {
-          sourceEventId = toolUseEvents[i].id;
-          break;
-        }
-      }
-      await db.update(messages).set({
-        turn_id: turnId,
-        ...sourceEventId != null ? { source_event_id: sourceEventId } : {}
-      }).where(eq5(messages.id, Number(orphan.message_id)));
-    }
-  }
-  dlog2.info(`tagged ${orphans.length} orphaned outbound record(s) for ${mind} with turn ${turnId}`);
-}
-async function tagUntaggedInbound(mind, turnId, {
-  limit = 5,
-  setTrigger = false,
-  channel
-} = {}) {
-  const db = await getDb();
-  const tagHistoryPromise = (async () => {
-    if (!channel) return;
-    const historyConditions = [
-      eq5(mindHistory.mind, mind),
-      eq5(mindHistory.type, "inbound"),
-      sql3`${mindHistory.turn_id} IS NULL`,
-      sql3`${mindHistory.created_at} > datetime('now', '-60 seconds')`,
-      eq5(mindHistory.channel, channel)
-    ];
-    const recentInbounds = await db.select({ id: mindHistory.id }).from(mindHistory).where(and4(...historyConditions)).orderBy(desc(mindHistory.id)).limit(limit);
-    if (recentInbounds.length > 0) {
-      const ids = recentInbounds.map((r) => r.id);
-      await db.update(mindHistory).set({ turn_id: turnId }).where(inArray2(mindHistory.id, ids));
-      if (setTrigger) {
-        await db.update(turns).set({ trigger_event_id: recentInbounds[0].id }).where(eq5(turns.id, turnId));
-      }
-    }
-  })();
-  const mindUserPromise = db.select({ id: users.id }).from(users).where(and4(eq5(users.username, mind), eq5(users.user_type, "mind"))).get();
-  const [tagResult, mindUserResult] = await Promise.allSettled([
-    tagHistoryPromise,
-    mindUserPromise
-  ]);
-  if (tagResult.status === "rejected") {
-    dlog2.error("failed to tag history inbound", logger_default.errorData(tagResult.reason));
-  }
-  const mindUser = mindUserResult.status === "fulfilled" ? mindUserResult.value : void 0;
-  const mindConvIds = mindUser ? (await db.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(eq5(conversationParticipants.user_id, mindUser.id))).map((r) => r.conversation_id) : [];
-  const recentMsgs = mindConvIds.length > 0 ? await db.select({ id: messages.id }).from(messages).where(
-    and4(
-      inArray2(messages.conversation_id, mindConvIds),
-      sql3`${messages.turn_id} IS NULL`,
-      sql3`${messages.sender_name} != ${mind}`,
-      sql3`${messages.created_at} > datetime('now', '-60 seconds')`
-    )
-  ).orderBy(desc(messages.id)).limit(limit) : [];
-  if (recentMsgs.length > 0) {
-    const ids = recentMsgs.map((r) => r.id);
-    await db.update(messages).set({ turn_id: turnId }).where(inArray2(messages.id, ids));
-  }
-}
-async function tagRecentInbound(mind, session, channel) {
-  const turnId = getActiveTurnId(mind, session);
-  if (!turnId) return;
-  try {
-    await tagUntaggedInbound(mind, turnId, { limit: 1, channel });
-  } catch (err) {
-    dlog2.warn(`failed to tag recent inbound for ${mind} with turn ${turnId}`, logger_default.errorData(err));
-  }
-}
 function resolveSleepAction(sleepBehavior, wokenByTrigger, wakeTriggerMatches) {
   if (sleepBehavior === "skip") return "skip";
   if (sleepBehavior === "trigger-wake" && !wokenByTrigger) return "queue-and-wake";
@@ -4450,7 +4643,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-F5KWIFOX.js");
+    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-BVU5D2AE.js");
     const sm = getSleepManagerIfReady2();
     if (sm) {
       const state = sm.getState(mindName);
@@ -4500,6 +4693,7 @@ export {
   sendSystemMessage,
   sendSystemMessageDirect,
   generateSystemReply,
+  checkHealth,
   RotatingLog,
   syncProviderToMinds,
   recordNotice,
@@ -4514,8 +4708,7 @@ export {
   initDeliveryManager,
   getDeliveryManager,
   tryGetDeliveryManager,
-  buildMindBaseEnv,
-  MindManager,
+  MindStartupError,
   initMindManager,
   getMindManager,
   invalidateMindUserCache,
@@ -4565,9 +4758,6 @@ export {
   recordInbound,
   recordOutbound,
   linkToolResultToTurn,
-  tagUntaggedOutbound,
-  tagUntaggedInbound,
-  tagRecentInbound,
   resolveSleepAction,
   deliverMessage,
   ensureSystemChannel,