volute 0.41.0 → 0.41.1

package/dist/{chunk-W5Z2H3LU.js → chunk-F44AEQAW.js}

@@ -1,16 +1,16 @@
 #!/usr/bin/env node
 import {
   loadMergedEnv
-} from "./chunk-6ZAT5PYV.js";
+} from "./chunk-BLOAJLGI.js";
 import {
   spiritDir
-} from "./chunk-YN6ISG7A.js";
+} from "./chunk-MYJSKXGH.js";
 import {
   hashSkillDir,
   importSkillFromDir,
   removeSharedSkill,
   sharedSkillsDir
-} from "./chunk-JIGVTFIR.js";
+} from "./chunk-MJIJFCAH.js";
 import {
   addMessage,
   createChannel,
@@ -20,7 +20,7 @@ import {
   getParticipants,
   joinChannel,
   publish as publish2
-} from "./chunk-2R4JIZCB.js";
+} from "./chunk-YLTIEEVL.js";
 import {
   readVoluteConfig,
   writeVoluteConfig
@@ -28,53 +28,53 @@ import {
 import {
   isSandboxEnabled,
   wrapForSandbox
-} from "./chunk-U7UASV36.js";
+} from "./chunk-763WUVJQ.js";
 import {
   markIdle,
   onMindEvent
-} from "./chunk-PP5CGT2P.js";
+} from "./chunk-VBKRZCR7.js";
 import {
   extractTextContent,
   getRoutingConfig,
   resolveDeliveryMode,
   resolveRoute
-} from "./chunk-GMFCSXWB.js";
+} from "./chunk-62ICA2FF.js";
 import {
   clearMind,
   getActiveTurnId,
   getPrompt,
   publish as publish3,
   summarizeOrphanedTurns
-} from "./chunk-YATR5BXD.js";
+} from "./chunk-GCS64EAD.js";
 import {
   exec
-} from "./chunk-Y2XLASFJ.js";
+} from "./chunk-GN52E2DP.js";
 import {
   chownMindDir,
   isIsolationEnabled,
   mindUserName,
   wrapForIsolation
-} from "./chunk-4ED2DBNC.js";
+} from "./chunk-TFBQESH7.js";
 import {
   aiCompleteUtility,
   getAiConfig,
   resolveApiKey
-} from "./chunk-VK2YD7VJ.js";
+} from "./chunk-IJCZAYGT.js";
 import {
   readGlobalConfig,
   writeGlobalConfig
-} from "./chunk-N64Q7FMP.js";
+} from "./chunk-MA7MYEOK.js";
 import {
   getOrCreateMindUser,
   getOrCreateSystemUser,
   getUser,
   getUserByUsername,
   syncMindProfile
-} from "./chunk-6TPRURK5.js";
+} from "./chunk-5QG36RV7.js";
 import {
   publish,
   subscribe
-} from "./chunk-2RQIIKFC.js";
+} from "./chunk-K547QOCM.js";
 import {
   logger_default
 } from "./chunk-T2TP6ZC6.js";
@@ -83,11 +83,12 @@ import {
   getBaseName,
   getDb,
   mindDir,
+  mindTmpDir,
   setMindRunning,
   stateDir,
   voluteHome,
   voluteSystemDir
-} from "./chunk-VDODEQSJ.js";
+} from "./chunk-IUZ3EV2D.js";
 import {
   activity,
   conversationParticipants,
@@ -95,12 +96,13 @@ import {
   messages,
   mindHistory,
   mindNotices,
+  sessions,
   turns,
   users
 } from "./chunk-MHFAWJCC.js";
 
 // packages/daemon/src/lib/delivery/message-delivery.ts
-import { and as and4, desc, eq as eq4, inArray as inArray2, sql as sql3 } from "drizzle-orm";
+import { and as and4, desc, eq as eq5, inArray as inArray2, sql as sql3 } from "drizzle-orm";
 
 // packages/daemon/src/lib/daemon/sleep-manager.ts
 import { execFile as execFile2, spawn as spawnChild } from "child_process";
@@ -116,7 +118,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 eq2, inArray } from "drizzle-orm";
+import { and as and2, eq as eq3, inArray } from "drizzle-orm";
 
 // packages/daemon/src/lib/daemon/mind-manager.ts
 import { execFile, spawn } from "child_process";
@@ -440,6 +442,50 @@ var RestartTracker = class {
 // packages/daemon/src/lib/daemon/mind-manager.ts
 var mlog = logger_default.child("minds");
 var execFileAsync = promisify(execFile);
+var MIND_ENV_ALLOWLIST = [
+  "PATH",
+  "HOME",
+  "USER",
+  "LOGNAME",
+  "SHELL",
+  "LANG",
+  "LANGUAGE",
+  "LC_ALL",
+  "LC_CTYPE",
+  "LC_MESSAGES",
+  "TERM",
+  "TERMINFO",
+  "COLORTERM",
+  "TMPDIR",
+  "TMP",
+  "TEMP",
+  "TZ",
+  "NODE_ENV",
+  "__CF_USER_TEXT_ENCODING",
+  // Outbound proxy / custom-CA config — required for minds' HTTPS calls (incl.
+  // the Anthropic API) to succeed on hosts that reach the internet only via a
+  // corporate proxy or custom CA bundle. Previously inherited via ...process.env.
+  "HTTP_PROXY",
+  "HTTPS_PROXY",
+  "NO_PROXY",
+  "http_proxy",
+  "https_proxy",
+  "no_proxy",
+  "NODE_EXTRA_CA_CERTS",
+  "SSL_CERT_FILE",
+  "SSL_CERT_DIR"
+];
+function buildMindBaseEnv(source = process.env) {
+  const base = {};
+  for (const key of MIND_ENV_ALLOWLIST) {
+    if (source[key] !== void 0) base[key] = source[key];
+  }
+  for (const [key, value] of Object.entries(source)) {
+    if (key === "VOLUTE_DAEMON_TOKEN") continue;
+    if (key.startsWith("VOLUTE_")) base[key] = value;
+  }
+  return base;
+}
 function mindPidPath(name) {
   return resolve2(stateDir(name), "mind.pid");
 }
@@ -505,9 +551,12 @@ var MindManager = class {
     const mindStateDir = stateDir(name);
     const logsDir = resolve2(mindStateDir, "logs");
     mkdirSync2(logsDir, { recursive: true });
+    const mindTmp = mindTmpDir(dir);
+    mkdirSync2(mindTmp, { recursive: true });
     if (isIsolationEnabled()) {
       try {
         chownMindDir(mindStateDir, baseName);
+        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}`
@@ -520,13 +569,14 @@ var MindManager = class {
     const mindLocalBin = resolve2(dir, "home", ".local", "bin");
     const currentPath = process.env.PATH ?? "";
     const env = {
-      ...process.env,
+      ...buildMindBaseEnv(),
       ...mindEnv,
       VOLUTE_MIND: name,
       VOLUTE_STATE_DIR: stateDir(name),
       VOLUTE_MIND_DIR: dir,
       VOLUTE_MIND_PORT: String(port),
-      VOLUTE_DAEMON_TOKEN: mindToken,
+      VOLUTE_MIND_TOKEN: mindToken,
+      TMPDIR: mindTmp,
       PATH: `${mindLocalBin}:${currentPath}`,
       // Strip CLAUDECODE so the Agent SDK can spawn Claude Code subprocesses
       CLAUDECODE: void 0
@@ -628,8 +678,9 @@ var MindManager = class {
             const claudeDir = writeClaudeCredentials(resolve2(dir, "home"), baseName, oauth);
             env.CLAUDE_CONFIG_DIR = claudeDir;
           }
-        } else if (anthropicConfig?.apiKey) {
-          env.ANTHROPIC_API_KEY = anthropicConfig.apiKey;
+        } else {
+          const apiKey = await resolveApiKey("anthropic");
+          if (apiKey) env.ANTHROPIC_API_KEY = apiKey;
         }
       } catch (err) {
         mlog.error(`failed to inject Anthropic credentials for ${name}`, logger_default.errorData(err));
@@ -661,7 +712,7 @@ var MindManager = class {
       [spawnCmd, spawnArgs] = await wrapForSandbox(baseBin, baseArgs, dir, name, [
         dir,
         mindStateDir,
-        "/tmp"
+        mindTmp
       ]);
     } else {
       spawnCmd = baseBin;
@@ -787,7 +838,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-T3AXQB3R.js");
+        const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-OHM3TO62.js");
         const sleepState = getSleepManagerIfReady2()?.getState(name);
         if (sleepState?.sleeping) {
           mlog.info(`${name} is sleeping \u2014 skipping crash recovery`);
@@ -811,15 +862,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-EB52CQ5X.js");
+        const { getDeliveryManager: getDeliveryManager2 } = await import("./delivery-manager-CPADWRV2.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-RSIWUUJK.js").then(({ markIdle: markIdle2 }) => markIdle2(name)).catch((err) => mlog.warn(`failed to mark ${name} idle after crash`, logger_default.errorData(err)));
-      import("./activity-events-EQGBUEZ7.js").then(
+      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(
         ({ 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);
@@ -870,7 +921,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-EB52CQ5X.js");
+      const { getDeliveryManager: getDeliveryManager2 } = await import("./delivery-manager-CPADWRV2.js");
       getDeliveryManager2().clearMindSessions(name);
     } catch (err) {
       if (!(err instanceof Error && err.message.includes("not initialized"))) {
@@ -878,7 +929,7 @@ var MindManager = class {
       }
     }
     try {
-      const { clearEchoTextCache } = await import("./echo-text-QVPS6QDM.js");
+      const { clearEchoTextCache } = await import("./echo-text-GEDEEY7M.js");
       clearEchoTextCache(name);
     } catch (err) {
       mlog.debug(`failed to clear echo-text cache for ${name}`, logger_default.errorData(err));
@@ -1007,6 +1058,150 @@ async function announceToSystem(text) {
 import { existsSync as existsSync6, mkdirSync as mkdirSync4, readdirSync, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
 import { dirname, resolve as resolve4 } from "path";
 
+// packages/daemon/src/web/middleware/auth.ts
+import { timingSafeEqual } from "crypto";
+import { eq as eq2, lt } from "drizzle-orm";
+import { getCookie } from "hono/cookie";
+import { createMiddleware } from "hono/factory";
+var MIND_USER_CACHE_TTL = 5 * 60 * 1e3;
+var mindUserCache = /* @__PURE__ */ new Map();
+function invalidateMindUserCache(mindName) {
+  mindUserCache.delete(mindName);
+}
+function isValidDaemonToken(token) {
+  const expected = process.env.VOLUTE_DAEMON_TOKEN;
+  if (!expected || token.length !== expected.length) return false;
+  return timingSafeEqual(Buffer.from(token), Buffer.from(expected));
+}
+var SESSION_MAX_AGE = 365 * 24 * 60 * 60 * 1e3;
+var SESSION_CACHE_TTL = 5 * 60 * 1e3;
+var sessionCache = /* @__PURE__ */ new Map();
+function invalidateSessionCache(sessionId) {
+  sessionCache.delete(sessionId);
+}
+async function createSession(userId) {
+  const db = await getDb();
+  const sessionId = crypto.randomUUID();
+  await db.insert(sessions).values({ id: sessionId, userId, createdAt: Date.now() });
+  return sessionId;
+}
+async function deleteSession(sessionId) {
+  sessionCache.delete(sessionId);
+  const db = await getDb();
+  await db.delete(sessions).where(eq2(sessions.id, sessionId));
+}
+async function getSessionUserId(sessionId) {
+  const db = await getDb();
+  const row = await db.select().from(sessions).where(eq2(sessions.id, sessionId)).get();
+  if (!row) return void 0;
+  if (Date.now() - row.createdAt > SESSION_MAX_AGE) {
+    await db.delete(sessions).where(eq2(sessions.id, sessionId));
+    return void 0;
+  }
+  return row.userId;
+}
+async function cleanExpiredSessions() {
+  const db = await getDb();
+  const cutoff = Date.now() - SESSION_MAX_AGE;
+  await db.delete(sessions).where(lt(sessions.createdAt, cutoff));
+}
+var requireAdmin = createMiddleware(async (c, next) => {
+  const user = c.get("user");
+  if (user.role !== "admin") {
+    return c.json({ error: "Forbidden" }, 403);
+  }
+  await next();
+});
+var requireAdminOrSystem = createMiddleware(async (c, next) => {
+  const user = c.get("user");
+  if (user.role !== "admin" && user.role !== "system") {
+    return c.json({ error: "Forbidden" }, 403);
+  }
+  await next();
+});
+async function resolveSession(sessionId) {
+  const cached = sessionCache.get(sessionId);
+  if (cached && cached.expires > Date.now()) {
+    return cached.user;
+  }
+  const userId = await getSessionUserId(sessionId);
+  if (userId == null) {
+    sessionCache.delete(sessionId);
+    return null;
+  }
+  const user = await getUser(userId);
+  if (!user) {
+    sessionCache.delete(sessionId);
+    return null;
+  }
+  sessionCache.set(sessionId, { userId, user, expires: Date.now() + SESSION_CACHE_TTL });
+  return user;
+}
+var authMiddleware = createMiddleware(async (c, next) => {
+  const authHeader = c.req.header("Authorization");
+  if (authHeader?.startsWith("Bearer ")) {
+    const token = authHeader.slice(7);
+    if (token && isValidDaemonToken(token)) {
+      c.set("user", {
+        id: 0,
+        username: "daemon",
+        role: "admin",
+        user_type: "brain",
+        display_name: null,
+        description: null,
+        avatar: null
+      });
+      const mindSessionHeader = c.req.header("X-Volute-Session");
+      if (mindSessionHeader) c.set("mindSession", mindSessionHeader);
+      await next();
+      return;
+    }
+    const mindName = resolveMindToken(token);
+    if (mindName) {
+      const cached = mindUserCache.get(mindName);
+      let mindUser;
+      if (cached && Date.now() - cached.ts < MIND_USER_CACHE_TTL) {
+        mindUser = cached.user;
+      } else {
+        mindUser = await getOrCreateMindUser(mindName);
+        mindUserCache.set(mindName, { user: mindUser, ts: Date.now() });
+      }
+      c.set("user", mindUser);
+      const mindSessionHeader = c.req.header("X-Volute-Session");
+      if (mindSessionHeader) c.set("mindSession", mindSessionHeader);
+      await next();
+      return;
+    }
+    if (token) {
+      const user2 = await resolveSession(token);
+      if (user2) {
+        if (user2.role === "pending") return c.json({ error: "Account pending approval" }, 403);
+        c.set("user", user2);
+        await next();
+        return;
+      }
+    }
+  }
+  const sessionId = getCookie(c, "volute_session");
+  if (!sessionId) return c.json({ error: "Unauthorized" }, 401);
+  const user = await resolveSession(sessionId);
+  if (!user) return c.json({ error: "Unauthorized" }, 401);
+  if (user.role === "pending") return c.json({ error: "Account pending approval" }, 403);
+  c.set("user", user);
+  await next();
+});
+var requireSelf = (paramName = "name") => createMiddleware(async (c, next) => {
+  const user = c.get("user");
+  if (user.role !== "admin" && user.role !== "system") {
+    const target = c.req.param(paramName) ?? "";
+    const baseName = await getBaseName(target);
+    if (user.username !== baseName) {
+      return c.json({ error: "Forbidden" }, 403);
+    }
+  }
+  await next();
+});
+
 // packages/daemon/src/lib/config/systems-config.ts
 import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "fs";
 import { resolve as resolve3 } from "path";
@@ -1144,6 +1339,10 @@ async function buildContext(manifest, dataDir, authMw) {
   return {
     db,
     authMiddleware: authMw,
+    // Reuse the daemon's canonical guard so extension routes authorize the same
+    // way core routes do (admin/system or the mind whose base name matches the
+    // route param). Its type is compatible with the SDK MiddlewareHandler.
+    requireSelf: (paramName) => requireSelf(paramName),
     resolveUser: (c) => {
       const user = c.get("user");
       if (!user || typeof user !== "object") return null;
@@ -1210,7 +1409,8 @@ async function loadExtension(manifest, app, authMw) {
           return c.json({ error: "Invalid JSON in request body" }, 400);
         }
         const user = c.get("user");
-        const mindName = body.mind || user?.username;
+        const privileged = user?.role === "admin" || user?.role === "system";
+        const mindName = privileged ? body.mind || user?.username : user?.username;
         const session = c.get("mindSession");
         try {
           const activityPromises = [];
@@ -1361,8 +1561,8 @@ function resolveSkillsDir(manifest) {
 }
 async function discoverBuiltinExtensions(disabledIds) {
   const builtins = [
-    { id: "notes", load: async () => (await import("./src-OYWRPLC6.js")).default },
-    { id: "pages", load: async () => (await import("./src-4LFGGNW7.js")).default },
+    { id: "notes", load: async () => (await import("./src-L2Z7X5UT.js")).default },
+    { id: "pages", load: async () => (await import("./src-TJ7RBU5H.js")).default },
     { id: "plan", load: async () => (await import("./src-O4PRLMKM.js")).default }
   ];
   const results = [];
@@ -1603,9 +1803,9 @@ async function installNpmExtension(pkg) {
     throw new Error(`Extension "${pkg}" is already installed`);
   }
   const dir = ensureExtensionsNpmDir();
-  const { exec: exec2 } = await import("./exec-R2WWZ6FH.js");
+  const { exec: exec2 } = await import("./exec-ZDD7NEB4.js");
   try {
-    await exec2("npm", ["install", pkg], { cwd: dir });
+    await exec2("npm", ["install", "--ignore-scripts", pkg], { cwd: dir });
   } catch (err) {
     logger_default.error(`npm install failed for "${pkg}"`, logger_default.errorData(err));
     throw new Error(`Failed to install "${pkg}". Check daemon logs for details.`);
@@ -1624,8 +1824,8 @@ async function uninstallNpmExtension(pkg) {
   packages.splice(idx, 1);
   writeExtensionsConfig(packages);
   try {
-    const { exec: exec2 } = await import("./exec-R2WWZ6FH.js");
-    await exec2("npm", ["uninstall", pkg], { cwd: extensionsNpmDir() });
+    const { exec: exec2 } = await import("./exec-ZDD7NEB4.js");
+    await exec2("npm", ["uninstall", "--ignore-scripts", pkg], { cwd: extensionsNpmDir() });
   } catch (err) {
     logger_default.warn(
       `npm uninstall failed for "${pkg}" (may have been manually removed)`,
@@ -2105,7 +2305,15 @@ ${stderr}` : ""}`;
       );
     }
   }
-  runScript(script, cwd, mindName) {
+  async runScript(script, cwd, 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("bash", ["-c", script], { cwd, mindName });
   }
   deliverSystem(mindName, text, opts) {
@@ -2417,7 +2625,7 @@ async function wakeMind(name) {
 async function startSpiritFull(name) {
   const entry = await findMind(name);
   if (entry?.dir) {
-    const { registerMindDir } = await import("./delivery-router-Y66OXJPM.js");
+    const { registerMindDir } = await import("./delivery-router-FDBZJQOY.js");
     registerMindDir(name, entry.dir);
   }
   await getMindManager().startMind(name);
@@ -2439,8 +2647,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-VYW2ECCE.js");
-  const { findDMConversation: findDMConversation2, createConversation: createConversation2 } = await import("./conversations-KW7IYESK.js");
+  const { getOrCreateMindUser: getOrCreateMindUser2, getUserByUsername: getUserByUsername2 } = await import("./auth-EAASQPTN.js");
+  const { findDMConversation: findDMConversation2, createConversation: createConversation2 } = await import("./conversations-FSZCUUYO.js");
   const mindUser = await getOrCreateMindUser2(mindName);
   const creatorUser = await getUserByUsername2(creatorUsername);
   if (!creatorUser) {
@@ -2782,9 +2990,9 @@ var SleepManager = class {
   async flushQueuedMessages(name) {
     try {
       const db = await getDb();
-      const rows = await db.select().from(deliveryQueue).where(and2(eq2(deliveryQueue.mind, name), eq2(deliveryQueue.status, "sleep-queued"))).all();
+      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-X4CZE2L6.js");
+      const { deliverMessage: deliverMessage2 } = await import("./message-delivery-HPMELC4Q.js");
       const delivered = [];
       for (const row of rows) {
         try {
@@ -2989,7 +3197,7 @@ var SleepManager = class {
   async buildQueuedSummary(name) {
     try {
       const db = await getDb();
-      const rows = await db.select({ channel: deliveryQueue.channel, sender: deliveryQueue.sender }).from(deliveryQueue).where(and2(eq2(deliveryQueue.mind, name), eq2(deliveryQueue.status, "sleep-queued"))).all();
+      const rows = await db.select({ channel: deliveryQueue.channel, sender: deliveryQueue.sender }).from(deliveryQueue).where(and2(eq3(deliveryQueue.mind, name), eq3(deliveryQueue.status, "sleep-queued"))).all();
       if (rows.length === 0) return "No messages arrived while you slept.";
       const channelCounts = /* @__PURE__ */ new Map();
       const senders = /* @__PURE__ */ new Set();
@@ -3105,7 +3313,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 eq3, sql as sql2 } from "drizzle-orm";
+import { and as and3, eq as eq4, sql as sql2 } from "drizzle-orm";
 
 // packages/daemon/src/lib/chat/typing.ts
 var DEFAULT_TTL_MS = 1e4;
@@ -3303,7 +3511,7 @@ var DeliveryManager = class {
   async restoreFromDb() {
     try {
       const db = await getDb();
-      const rows = await db.select().from(deliveryQueue).where(eq3(deliveryQueue.status, "pending"));
+      const rows = await db.select().from(deliveryQueue).where(eq4(deliveryQueue.status, "pending"));
       for (const row of rows) {
         let payload;
         try {
@@ -3321,7 +3529,7 @@ var DeliveryManager = class {
           this.addToBatchBuffer(row.mind, row.session, payload, sessionConfig);
         } else {
           try {
-            await db.delete(deliveryQueue).where(eq3(deliveryQueue.id, row.id));
+            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));
           }
@@ -3342,7 +3550,7 @@ var DeliveryManager = class {
    */
   async getPending(mindName) {
     const db = await getDb();
-    const rows = await db.select().from(deliveryQueue).where(and3(eq3(deliveryQueue.mind, mindName), eq3(deliveryQueue.status, "gated")));
+    const rows = await db.select().from(deliveryQueue).where(and3(eq4(deliveryQueue.mind, mindName), eq4(deliveryQueue.status, "gated")));
     const byChannel = /* @__PURE__ */ new Map();
     for (const row of rows) {
       const ch = row.channel ?? "unknown";
@@ -3559,9 +3767,9 @@ var DeliveryManager = class {
           const db = await getDb();
           await db.delete(deliveryQueue).where(
             and3(
-              eq3(deliveryQueue.mind, baseName),
-              eq3(deliveryQueue.session, session),
-              eq3(deliveryQueue.status, "pending")
+              eq4(deliveryQueue.mind, baseName),
+              eq4(deliveryQueue.session, session),
+              eq4(deliveryQueue.status, "pending")
             )
           );
         } catch (err) {
@@ -3689,9 +3897,9 @@ var DeliveryManager = class {
       const db = await getDb();
       const count = await db.select({ count: sql2`count(*)` }).from(deliveryQueue).where(
         and3(
-          eq3(deliveryQueue.mind, baseName),
-          eq3(deliveryQueue.channel, payload.channel),
-          eq3(deliveryQueue.status, "gated")
+          eq4(deliveryQueue.mind, baseName),
+          eq4(deliveryQueue.channel, payload.channel),
+          eq4(deliveryQueue.status, "gated")
         )
       );
       if ((count[0]?.count ?? 0) <= 1) {
@@ -3716,7 +3924,7 @@ 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-HCPHUQGI.js");
+    const { sendSystemMessage: sendSystemMessage2 } = await import("./system-chat-HZUKBIKJ.js");
     await sendSystemMessage2(mindName, notification);
   }
   async persistToQueue(mindName, session, payload, status = "pending") {
@@ -3955,18 +4163,18 @@ async function linkToolResultToTurn(mind, turnId, toolResultContent, toolUseEven
         channel: mindHistory.channel,
         content: mindHistory.content,
         message_id: mindHistory.message_id
-      }).from(mindHistory).where(and4(eq4(mindHistory.id, outboundId), eq4(mindHistory.mind, mind))).limit(1);
+      }).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(eq4(mindHistory.id, outboundId));
+      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(eq4(messages.id, Number(row.message_id)));
+        }).where(eq5(messages.id, Number(row.message_id)));
       }
       publish3(mind, {
         mind,
@@ -4012,14 +4220,14 @@ async function tagUntaggedOutbound(mind, turnId) {
   const range = await db.select({
     minId: sql3`MIN(${mindHistory.id})`,
     maxId: sql3`MAX(${mindHistory.id})`
-  }).from(mindHistory).where(and4(eq4(mindHistory.mind, mind), eq4(mindHistory.turn_id, turnId)));
+  }).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(
-      eq4(mindHistory.mind, mind),
-      eq4(mindHistory.type, "outbound"),
+      eq5(mindHistory.mind, mind),
+      eq5(mindHistory.type, "outbound"),
       sql3`${mindHistory.turn_id} IS NULL`,
       sql3`${mindHistory.id} >= ${minId}`,
       sql3`${mindHistory.id} <= ${maxId}`
@@ -4032,9 +4240,9 @@ async function tagUntaggedOutbound(mind, turnId) {
   if (orphansWithMessages.length > 0) {
     const toolUseEvents = await db.select({ id: mindHistory.id }).from(mindHistory).where(
       and4(
-        eq4(mindHistory.mind, mind),
-        eq4(mindHistory.turn_id, turnId),
-        eq4(mindHistory.type, "tool_use")
+        eq5(mindHistory.mind, mind),
+        eq5(mindHistory.turn_id, turnId),
+        eq5(mindHistory.type, "tool_use")
       )
     ).orderBy(mindHistory.id);
     for (const orphan of orphansWithMessages) {
@@ -4048,7 +4256,7 @@ async function tagUntaggedOutbound(mind, turnId) {
       await db.update(messages).set({
         turn_id: turnId,
         ...sourceEventId != null ? { source_event_id: sourceEventId } : {}
-      }).where(eq4(messages.id, Number(orphan.message_id)));
+      }).where(eq5(messages.id, Number(orphan.message_id)));
     }
   }
   dlog2.info(`tagged ${orphans.length} orphaned outbound record(s) for ${mind} with turn ${turnId}`);
@@ -4062,22 +4270,22 @@ async function tagUntaggedInbound(mind, turnId, {
   const tagHistoryPromise = (async () => {
     if (!channel) return;
     const historyConditions = [
-      eq4(mindHistory.mind, mind),
-      eq4(mindHistory.type, "inbound"),
+      eq5(mindHistory.mind, mind),
+      eq5(mindHistory.type, "inbound"),
       sql3`${mindHistory.turn_id} IS NULL`,
       sql3`${mindHistory.created_at} > datetime('now', '-60 seconds')`,
-      eq4(mindHistory.channel, channel)
+      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(eq4(turns.id, turnId));
+        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(eq4(users.username, mind), eq4(users.user_type, "mind"))).get();
+  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
@@ -4086,7 +4294,7 @@ async function tagUntaggedInbound(mind, turnId, {
     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(eq4(conversationParticipants.user_id, mindUser.id))).map((r) => r.conversation_id) : [];
+  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),
@@ -4242,7 +4450,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-T3AXQB3R.js");
+    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-OHM3TO62.js");
     const sm = getSleepManagerIfReady2();
     if (sm) {
       const state = sm.getState(mindName);
@@ -4294,7 +4502,6 @@ export {
   generateSystemReply,
   RotatingLog,
   syncProviderToMinds,
-  resolveMindToken,
   recordNotice,
   drainNotices,
   clearDeliveredNotices,
@@ -4307,9 +4514,21 @@ export {
   initDeliveryManager,
   getDeliveryManager,
   tryGetDeliveryManager,
+  buildMindBaseEnv,
   MindManager,
   initMindManager,
   getMindManager,
+  invalidateMindUserCache,
+  SESSION_MAX_AGE,
+  invalidateSessionCache,
+  createSession,
+  deleteSession,
+  getSessionUserId,
+  cleanExpiredSessions,
+  requireAdmin,
+  requireAdminOrSystem,
+  authMiddleware,
+  requireSelf,
   readSystemsConfig,
   writeSystemsConfig,
   deleteSystemsConfig,