volute 0.27.0 → 0.29.0

package/dist/daemon.js

@@ -3,11 +3,8 @@ import {
   addSharedWorktree,
   ensureSharedRepo,
   removeSharedWorktree,
-  sharedLog,
-  sharedMerge,
-  sharedPull,
-  sharedStatus
-} from "./chunk-JKOWNZ4P.js";
+  sharedMerge
+} from "./chunk-P72MVS4R.js";
 import {
   announceToSystem,
   approveUser,
@@ -15,15 +12,15 @@ import {
   countAdmins,
   createUser,
   deleteMindUser as deleteMindUser2,
+  deleteSystemsConfig,
   deleteUser,
   deliverMessage,
   ensureSystemChannel,
   extractTextContent,
-  getCachedRecentPages,
-  getCachedSites,
   getDeliveryManager,
   getOrCreateMindUser,
   getScheduler,
+  getSleepManagerIfReady,
   getTokenBudget,
   getTypingMap,
   getUser,
@@ -40,44 +37,26 @@ import {
   migrateMindRoles,
   publish as publish2,
   publishTypingForChannels,
+  readSystemsConfig,
   readVoluteConfig,
   recordInbound,
   resolveChannelId,
   setUserRole,
   splitMessage,
   startMindFull,
-  stopAllWatchers,
   stopMindFull,
   subscribe as subscribe3,
   updateUserProfile,
   verifyUser,
   writeChannelEntry,
+  writeSystemsConfig,
   writeVoluteConfig
-} from "./chunk-OQZH4PBB.js";
+} from "./chunk-CMILSHZD.js";
 import {
-  deleteSystemsConfig,
-  readSystemsConfig,
-  writeSystemsConfig
-} from "./chunk-KDGS53OS.js";
-import {
-  getActiveMinds,
-  onMindEvent,
-  stopAll
-} from "./chunk-K5NAC55T.js";
-import {
-  PROMPT_DEFAULTS,
-  PROMPT_KEYS,
-  RestartTracker,
-  RotatingLog,
-  getMindManager,
-  getMindPromptDefaults,
-  getPrompt,
-  getPromptIfCustom,
-  initMindManager,
-  resolveMindToken,
-  substitute
-} from "./chunk-PHSAT7YL.js";
-import "./chunk-USUXRNVD.js";
+  getCachedRecentPages,
+  getCachedSites,
+  stopAllWatchers
+} from "./chunk-THUUIU3E.js";
 import {
   addMessage,
   createChannel,
@@ -92,21 +71,24 @@ import {
   getParticipants,
   getUnreadCounts,
   initWebhook,
+  isConversationForMind,
   isParticipant,
   isParticipantOrOwner,
   joinChannel,
   leaveChannel,
   listChannels,
+  listConversationsForMind,
   listConversationsForUser,
   listConversationsWithParticipants,
   markConversationRead,
   publish,
   subscribe as subscribe2
-} from "./chunk-IAYBDWVG.js";
+} from "./chunk-FLZGS4QH.js";
 import {
-  broadcast,
-  subscribe
-} from "./chunk-VIVMW2H2.js";
+  checkForUpdate,
+  checkForUpdateCached,
+  getCurrentVersion
+} from "./chunk-HDN7MNGD.js";
 import {
   applyInitFiles,
   composeTemplate,
@@ -115,6 +97,29 @@ import {
   findTemplatesRoot,
   listFiles
 } from "./chunk-AKPFNL7L.js";
+import {
+  getActiveMinds,
+  onMindEvent,
+  stopAll
+} from "./chunk-CQ7SNKNI.js";
+import {
+  broadcast,
+  subscribe
+} from "./chunk-VIVMW2H2.js";
+import {
+  PROMPT_DEFAULTS,
+  PROMPT_KEYS,
+  RestartTracker,
+  RotatingLog,
+  getMindManager,
+  getMindPromptDefaults,
+  getPrompt,
+  getPromptIfCustom,
+  initMindManager,
+  resolveMindToken,
+  substitute
+} from "./chunk-EHZKEMMV.js";
+import "./chunk-J4IBNXGJ.js";
 import {
   SEED_SKILLS,
   STANDARD_SKILLS,
@@ -130,12 +135,15 @@ import {
   syncBuiltinSkills,
   uninstallSkill,
   updateSkill
-} from "./chunk-4WXYUOAK.js";
+} from "./chunk-NI5FFCCS.js";
 import {
-  checkForUpdate,
-  checkForUpdateCached,
-  getCurrentVersion
-} from "./chunk-HDN7MNGD.js";
+  acceptPending,
+  formatFileSize,
+  listPending,
+  rejectPending,
+  stageFile,
+  validateFilePath
+} from "./chunk-MD4C26II.js";
 import {
   findBridgeForChannel,
   findOpenClawSession,
@@ -182,7 +190,7 @@ import "./chunk-D424ZQGI.js";
 import {
   buildVoluteSlug,
   slugify
-} from "./chunk-T6HKBWXZ.js";
+} from "./chunk-A6TUJJ3L.js";
 import {
   activity,
   addMind,
@@ -220,10 +228,10 @@ import {
 } from "./chunk-K3NQKI34.js";
 
 // src/daemon.ts
-import { randomBytes as randomBytes2 } from "crypto";
-import { mkdirSync as mkdirSync12, readFileSync as readFileSync14, unlinkSync as unlinkSync2, writeFileSync as writeFileSync11 } from "fs";
+import { randomBytes } from "crypto";
+import { mkdirSync as mkdirSync11, readFileSync as readFileSync13, unlinkSync as unlinkSync2, writeFileSync as writeFileSync10 } from "fs";
 import { homedir as homedir2 } from "os";
-import { resolve as resolve23 } from "path";
+import { resolve as resolve22 } from "path";
 import { format } from "util";
 
 // src/lib/daemon/bridge-manager.ts
@@ -433,8 +441,8 @@ var BridgeManager = class {
     if (!tracked) return;
     this.stopping.add(platform);
     this.bridges.delete(platform);
-    await new Promise((resolve24) => {
-      tracked.child.on("exit", () => resolve24());
+    await new Promise((resolve23) => {
+      tracked.child.on("exit", () => resolve23());
       try {
         if (tracked.child.pid) {
           process.kill(-tracked.child.pid, "SIGTERM");
@@ -445,7 +453,7 @@ var BridgeManager = class {
         if (err instanceof Error && err.code !== "ESRCH") {
           blog.warn(`failed to stop bridge ${platform}`, logger_default.errorData(err));
         }
-        resolve24();
+        resolve23();
       }
       setTimeout(() => {
         try {
@@ -456,7 +464,7 @@ var BridgeManager = class {
           }
         } catch {
         }
-        resolve24();
+        resolve23();
       }, 5e3);
     });
     this.stopping.delete(platform);
@@ -544,6 +552,15 @@ function getBridgeManager() {
   return instance;
 }
 
+// src/lib/history-cleanup.ts
+import { and, eq, lt } from "drizzle-orm";
+var LOG_RETENTION_MS = 24 * 60 * 60 * 1e3;
+async function cleanExpiredLogs() {
+  const db = await getDb();
+  const cutoff = new Date(Date.now() - LOG_RETENTION_MS).toISOString().replace("T", " ").slice(0, 19);
+  await db.delete(mindHistory).where(and(eq(mindHistory.type, "log"), lt(mindHistory.created_at, cutoff)));
+}
+
 // src/lib/migrate-agents-to-minds.ts
 import { execFileSync } from "child_process";
 import { existsSync as existsSync3, readFileSync as readFileSync3, renameSync, writeFileSync as writeFileSync2 } from "fs";
@@ -803,7 +820,7 @@ function migrateToSystemDir() {
 
 // src/web/middleware/auth.ts
 import { timingSafeEqual } from "crypto";
-import { eq, lt } from "drizzle-orm";
+import { eq as eq2, lt as lt2 } from "drizzle-orm";
 import { getCookie } from "hono/cookie";
 import { createMiddleware } from "hono/factory";
 function isValidDaemonToken(token) {
@@ -826,14 +843,14 @@ async function createSession(userId) {
 async function deleteSession(sessionId) {
   sessionCache.delete(sessionId);
   const db = await getDb();
-  await db.delete(sessions).where(eq(sessions.id, sessionId));
+  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(eq(sessions.id, sessionId)).get();
+  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(eq(sessions.id, sessionId));
+    await db.delete(sessions).where(eq2(sessions.id, sessionId));
     return void 0;
   }
   return row.userId;
@@ -841,7 +858,7 @@ async function getSessionUserId(sessionId) {
 async function cleanExpiredSessions() {
   const db = await getDb();
   const cutoff = Date.now() - SESSION_MAX_AGE;
-  await db.delete(sessions).where(lt(sessions.createdAt, cutoff));
+  await db.delete(sessions).where(lt2(sessions.createdAt, cutoff));
 }
 var requireAdmin = createMiddleware(async (c, next) => {
   const user = c.get("user");
@@ -923,10 +940,10 @@ var requireSelf = (paramName = "name") => createMiddleware(async (c, next) => {
 });
 
 // src/web/server.ts
-import { existsSync as existsSync17 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { readFile as readFile4, stat as stat4 } from "fs/promises";
 import { createServer as createHttpsServer } from "https";
-import { dirname as dirname2, extname as extname5, resolve as resolve22 } from "path";
+import { dirname as dirname2, extname as extname5, resolve as resolve21 } from "path";
 import { serve } from "@hono/node-server";
 
 // src/web/app.ts
@@ -997,8 +1014,8 @@ var app = new Hono().get("/events", async (c) => {
         });
       }, 15e3);
       cleanups.push(() => clearInterval(keepAlive));
-      await new Promise((resolve24) => {
-        stream.onAbort(() => resolve24());
+      await new Promise((resolve23) => {
+        stream.onAbort(() => resolve23());
       });
     } finally {
       for (const cleanup of cleanups) {
@@ -1277,7 +1294,7 @@ import { Hono as Hono3 } from "hono";
 import { z as z2 } from "zod";
 
 // src/lib/puppets.ts
-import { and, eq as eq2 } from "drizzle-orm";
+import { and as and2, eq as eq3 } from "drizzle-orm";
 async function findOrCreatePuppet(platform, platformId, displayName) {
   const username = `${platform}:${platformId}`;
   const db = await getDb();
@@ -1286,10 +1303,10 @@ async function findOrCreatePuppet(platform, platformId, displayName) {
     username: users.username,
     display_name: users.display_name,
     avatar: users.avatar
-  }).from(users).where(and(eq2(users.username, username), eq2(users.user_type, "puppet"))).get();
+  }).from(users).where(and2(eq3(users.username, username), eq3(users.user_type, "puppet"))).get();
   if (existing) {
     if (existing.display_name !== displayName) {
-      await db.update(users).set({ display_name: displayName }).where(eq2(users.id, existing.id));
+      await db.update(users).set({ display_name: displayName }).where(eq3(users.id, existing.id));
       existing.display_name = displayName;
     }
     return existing;
@@ -1315,7 +1332,7 @@ async function findOrCreatePuppet(platform, platformId, displayName) {
         username: users.username,
         display_name: users.display_name,
         avatar: users.avatar
-      }).from(users).where(and(eq2(users.username, username), eq2(users.user_type, "puppet"))).get();
+      }).from(users).where(and2(eq3(users.username, username), eq3(users.user_type, "puppet"))).get();
       if (retried) return retried;
     }
     throw err;
@@ -1397,7 +1414,7 @@ var app3 = new Hono3().post("/:platform/inbound", zValidator2("json", inboundSch
   }
   const participants = await getParticipants(channel.id);
   if (!participants.some((p) => p.userId === puppet.id)) {
-    const { addParticipant } = await import("./conversations-M2K4253F.js");
+    const { addParticipant } = await import("./conversations-P5BL7RMX.js");
     await addParticipant(channel.id, puppet.id);
   }
   const contentBlocks = body.content;
@@ -1490,10 +1507,10 @@ async function fanOutToBridgedMinds(opts) {
   const participants = await getParticipants(opts.conversationId);
   const mindParticipants = participants.filter((p) => p.userType === "mind");
   const participantNames = participants.map((p) => p.username);
-  const { getMindManager: getMindManager2 } = await import("./mind-manager-M6EMUW5I.js");
-  const { getSleepManagerIfReady } = await import("./sleep-manager-MWYHM5HV.js");
+  const { getMindManager: getMindManager2 } = await import("./mind-manager-P66HQDNE.js");
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G4B5GW5P.js");
   const manager = getMindManager2();
-  const sm = getSleepManagerIfReady();
+  const sm = getSleepManagerIfReady2();
   const targetMinds = mindParticipants.filter((ap) => {
     return (manager.isRunning(ap.username) || sm?.isSleeping(ap.username)) && ap.username !== opts.senderName;
   }).map((ap) => ap.username);
@@ -1508,7 +1525,7 @@ async function fanOutToBridgedMinds(opts) {
       writeChannelEntry(mindName, channel, {
         platformId: opts.conversationId,
         platform: "volute",
-        type: opts.isDM ? "dm" : "group"
+        type: opts.isDM ? "dm" : "channel"
       });
     } catch (err) {
       logger_default.warn(`failed to write channel entry for ${mindName}`, logger_default.errorData(err));
@@ -1636,7 +1653,7 @@ async function listConversations(env) {
       id: slug,
       platformId: dm.id,
       name: recipients.join(", ") || "DM",
-      type: dm.type === 1 ? "dm" : "group"
+      type: dm.type === 1 ? "dm" : "channel"
     });
   }
   return results;
@@ -1806,7 +1823,6 @@ async function listConversations2(env) {
   return data.channels.map((ch) => {
     let type = "channel";
     if (ch.is_im) type = "dm";
-    else if (ch.is_mpim) type = "group";
     let slug;
     let name;
     if (ch.is_im && ch.user) {
@@ -1883,7 +1899,7 @@ async function createConversation3(env, participants, name) {
       platformId,
       platform: "slack",
       name: participants.join(", "),
-      type: participants.length === 1 ? "dm" : "group"
+      type: participants.length === 1 ? "dm" : "channel"
     });
   }
   return slug;
@@ -1999,18 +2015,18 @@ import { resolve as resolve7 } from "path";
 function getDaemonConfig() {
   const newPath = resolve7(voluteSystemDir(), "daemon.json");
   const legacyPath = resolve7(voluteHome(), "daemon.json");
-  const configPath2 = existsSync7(newPath) ? newPath : legacyPath;
-  if (!existsSync7(configPath2)) {
+  const configPath = existsSync7(newPath) ? newPath : legacyPath;
+  if (!existsSync7(configPath)) {
     throw new Error("Volute daemon is not running");
   }
   let config;
   try {
-    config = JSON.parse(readFileSync5(configPath2, "utf-8"));
+    config = JSON.parse(readFileSync5(configPath, "utf-8"));
   } catch (err) {
-    throw new Error(`Failed to parse ${configPath2}: ${err}`);
+    throw new Error(`Failed to parse ${configPath}: ${err}`);
   }
   if (typeof config.port !== "number") {
-    throw new Error(`Invalid or missing port in ${configPath2}`);
+    throw new Error(`Invalid or missing port in ${configPath}`);
   }
   const url = new URL("http://localhost");
   url.hostname = config.hostname || "localhost";
@@ -2099,7 +2115,7 @@ async function listConversations4(env) {
       convType: conv.type,
       convName: conv.name
     });
-    const convType = conv.type === "channel" ? "channel" : participants.length === 2 ? "dm" : "group";
+    const convType = conv.type === "channel" ? "channel" : "dm";
     results.push({
       id: slug,
       platformId: conv.id,
@@ -2304,7 +2320,7 @@ var app5 = new Hono5().get("/:name/env", async (c) => {
   const value = merged[key];
   if (value === void 0) return c.json({ error: "Key not found" }, 404);
   return c.json({ value });
-}).put("/:name/env/:key", requireAdmin, async (c) => {
+}).put("/:name/env/:key", requireSelf(), async (c) => {
   const name = c.req.param("name");
   if (!await findMind(name)) return c.json({ error: "Mind not found" }, 404);
   const key = c.req.param("key");
@@ -2322,7 +2338,7 @@ var app5 = new Hono5().get("/:name/env", async (c) => {
   env[key] = body.value;
   writeEnv(path, env);
   return c.json({ ok: true });
-}).delete("/:name/env/:key", requireAdmin, async (c) => {
+}).delete("/:name/env/:key", requireSelf(), async (c) => {
   const name = c.req.param("name");
   if (!await findMind(name)) return c.json({ error: "Mind not found" }, 404);
   const key = c.req.param("key");
@@ -2363,165 +2379,9 @@ var sharedEnvApp = new Hono5().get("/", (c) => {
 var env_default = app5;
 
 // src/web/api/file-sharing.ts
-import { readFileSync as readFileSync7, statSync } from "fs";
-import { resolve as resolve9 } from "path";
+import { readFileSync as readFileSync6, statSync } from "fs";
+import { resolve as resolve8 } from "path";
 import { Hono as Hono6 } from "hono";
-
-// src/lib/file-sharing.ts
-import { randomBytes } from "crypto";
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readdirSync as readdirSync2, readFileSync as readFileSync6, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "fs";
-import { basename, join, normalize, resolve as resolve8 } from "path";
-function validateFilePath(filePath) {
-  if (!filePath) return "File path is required";
-  const normalized = normalize(filePath);
-  if (normalized.startsWith("/") || normalized.startsWith("\\")) {
-    return "Absolute paths are not allowed";
-  }
-  if (normalized.includes("..")) {
-    return "Path traversal (..) is not allowed";
-  }
-  return null;
-}
-function configPath(dir) {
-  return resolve8(dir, "home", ".config", "file-sharing.json");
-}
-function readFileSharingConfig(dir) {
-  const p = configPath(dir);
-  if (!existsSync8(p)) return {};
-  try {
-    return JSON.parse(readFileSync6(p, "utf-8"));
-  } catch (err) {
-    console.warn(`[file-sharing] failed to parse config at ${p}:`, err);
-    return {};
-  }
-}
-function writeFileSharingConfig(dir, config) {
-  const p = configPath(dir);
-  mkdirSync5(resolve8(p, ".."), { recursive: true });
-  writeFileSync4(p, `${JSON.stringify(config, null, 2)}
-`);
-}
-function isTrustedSender(dir, sender) {
-  const config = readFileSharingConfig(dir);
-  return config.trustedSenders?.includes(sender) ?? false;
-}
-function addTrust(dir, sender) {
-  const config = readFileSharingConfig(dir);
-  const trusted = config.trustedSenders ?? [];
-  if (!trusted.includes(sender)) {
-    trusted.push(sender);
-  }
-  config.trustedSenders = trusted;
-  writeFileSharingConfig(dir, config);
-}
-function removeTrust(dir, sender) {
-  const config = readFileSharingConfig(dir);
-  const trusted = config.trustedSenders ?? [];
-  config.trustedSenders = trusted.filter((s) => s !== sender);
-  writeFileSharingConfig(dir, config);
-}
-function pendingDir(receiver) {
-  return resolve8(stateDir(receiver), "pending-files");
-}
-function validateId(id) {
-  if (!id || id.includes("/") || id.includes("\\") || id.includes("..")) {
-    throw new Error("Invalid pending file id");
-  }
-}
-function generateId(sender) {
-  const ts = Date.now();
-  const rand = randomBytes(2).toString("hex");
-  return `${sender}-${ts}-${rand}`;
-}
-function stageFile(receiver, sender, filename, content, originalPath) {
-  const err = validateFilePath(filename);
-  if (err) throw new Error(err);
-  if (sender.includes("/") || sender.includes("\\")) {
-    throw new Error("Invalid sender name");
-  }
-  const id = generateId(sender);
-  const dir = resolve8(pendingDir(receiver), id);
-  mkdirSync5(dir, { recursive: true });
-  const metadata = {
-    id,
-    sender,
-    filename: basename(filename),
-    originalPath,
-    size: content.length,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  writeFileSync4(resolve8(dir, "metadata.json"), `${JSON.stringify(metadata, null, 2)}
-`);
-  writeFileSync4(resolve8(dir, "data"), content);
-  return { id };
-}
-function listPending(receiver) {
-  const dir = pendingDir(receiver);
-  if (!existsSync8(dir)) return [];
-  const entries = readdirSync2(dir, { withFileTypes: true });
-  const result = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const metaPath = resolve8(dir, entry.name, "metadata.json");
-    if (!existsSync8(metaPath)) continue;
-    try {
-      result.push(JSON.parse(readFileSync6(metaPath, "utf-8")));
-    } catch (err) {
-      console.warn(`[file-sharing] skipping malformed pending entry ${entry.name}:`, err);
-    }
-  }
-  return result.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-}
-function getPending(receiver, id) {
-  validateId(id);
-  const metaPath = resolve8(pendingDir(receiver), id, "metadata.json");
-  if (!existsSync8(metaPath)) return null;
-  try {
-    return JSON.parse(readFileSync6(metaPath, "utf-8"));
-  } catch (err) {
-    console.warn(`[file-sharing] failed to read pending metadata for ${id}:`, err);
-    return null;
-  }
-}
-function deliverFile(receiverDir, sender, filename, content, inboxPath) {
-  const err = validateFilePath(filename);
-  if (err) throw new Error(err);
-  const inbox = inboxPath ?? "inbox";
-  const inboxErr = validateFilePath(inbox);
-  if (inboxErr) throw new Error(`Invalid inboxPath: ${inboxErr}`);
-  if (sender.includes("/") || sender.includes("\\")) {
-    throw new Error("Invalid sender name");
-  }
-  const destDir = resolve8(receiverDir, "home", inbox, sender);
-  mkdirSync5(destDir, { recursive: true });
-  const destPath = resolve8(destDir, basename(filename));
-  writeFileSync4(destPath, content);
-  return join(inbox, sender, basename(filename));
-}
-function acceptPending(receiver, id, receiverDir) {
-  const meta = getPending(receiver, id);
-  if (!meta) throw new Error(`Pending file not found: ${id}`);
-  const dataPath = resolve8(pendingDir(receiver), id, "data");
-  const content = readFileSync6(dataPath);
-  const config = readFileSharingConfig(receiverDir);
-  const inboxPath = config.inboxPath ?? "inbox";
-  const destPath = deliverFile(receiverDir, meta.sender, meta.filename, content, inboxPath);
-  rmSync3(resolve8(pendingDir(receiver), id), { recursive: true });
-  return { sender: meta.sender, filename: meta.filename, destPath };
-}
-function rejectPending(receiver, id) {
-  const meta = getPending(receiver, id);
-  if (!meta) throw new Error(`Pending file not found: ${id}`);
-  rmSync3(resolve8(pendingDir(receiver), id), { recursive: true });
-  return { sender: meta.sender, filename: meta.filename };
-}
-function formatFileSize(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-
-// src/web/api/file-sharing.ts
 async function notifyMind(port, message, channel, sender) {
   try {
     const res = await fetch(`http://127.0.0.1:${port}/message`, {
@@ -2553,7 +2413,7 @@ var app6 = new Hono6().post("/:name/files/send", requireSelf(), async (c) => {
   const pathErr = validateFilePath(body.filePath);
   if (pathErr) return c.json({ error: pathErr }, 400);
   const senderDir = mindDir(senderName);
-  const filePath = resolve9(senderDir, "home", body.filePath);
+  const filePath = resolve8(senderDir, "home", body.filePath);
   const MAX_FILE_SIZE2 = 50 * 1024 * 1024;
   const stat5 = statSync(filePath, { throwIfNoEntry: false });
   if (!stat5) return c.json({ error: `File not found: ${body.filePath}` }, 404);
@@ -2567,31 +2427,21 @@ var app6 = new Hono6().post("/:name/files/send", requireSelf(), async (c) => {
   }
   let content;
   try {
-    content = readFileSync7(filePath);
-  } catch {
-    return c.json({ error: `File not found: ${body.filePath}` }, 404);
+    content = readFileSync6(filePath);
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      return c.json({ error: `File not found: ${body.filePath}` }, 404);
+    }
+    return c.json({ error: `Failed to read file: ${code ?? err.message}` }, 500);
   }
-  const receiverDir = mindDir(body.targetMind);
   const filename = body.filePath;
   const sizeStr = formatFileSize(content.length);
-  if (isTrustedSender(receiverDir, senderName)) {
-    const config = readFileSharingConfig(receiverDir);
-    const destPath = deliverFile(receiverDir, senderName, filename, content, config.inboxPath);
-    if (receiverEntry.running) {
-      await notifyMind(
-        receiverEntry.port,
-        `[file] ${senderName} sent ${filename} (${sizeStr}) \u2192 ${destPath}`,
-        "system:file-sharing",
-        senderName
-      );
-    }
-    return c.json({ status: "delivered", destPath }, 200);
-  }
   const { id } = stageFile(body.targetMind, senderName, filename, content, body.filePath);
   if (receiverEntry.running) {
     await notifyMind(
       receiverEntry.port,
-      `[file] ${senderName} wants to send ${filename} (${sizeStr}) \u2014 run: volute file accept ${id}`,
+      `[file] ${senderName} sent ${filename} (${sizeStr}) \u2014 run: volute chat accept ${id}`,
       "system:file-sharing",
       senderName
     );
@@ -2607,9 +2457,13 @@ var app6 = new Hono6().post("/:name/files/send", requireSelf(), async (c) => {
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const body = await c.req.json();
   if (!body.id) return c.json({ error: "id is required" }, 400);
+  if (body.dest) {
+    const destErr = validateFilePath(body.dest);
+    if (destErr) return c.json({ error: `Invalid dest: ${destErr}` }, 400);
+  }
   let result;
   try {
-    result = acceptPending(name, body.id, mindDir(name));
+    result = acceptPending(name, body.id, mindDir(name), body.dest);
   } catch (err) {
     const message = err.message;
     if (message.includes("not found") || message.includes("Invalid pending")) {
@@ -2652,26 +2506,44 @@ var app6 = new Hono6().post("/:name/files/send", requireSelf(), async (c) => {
     );
   }
   return c.json({ ok: true });
-}).post("/:name/files/trust", async (c) => {
-  const name = c.req.param("name");
-  if (!await findMind(name)) return c.json({ error: "Mind not found" }, 404);
+}).post("/:name/files/stage", async (c) => {
+  const receiverName = c.req.param("name");
+  const receiverEntry = await findMind(receiverName);
+  if (!receiverEntry) return c.json({ error: "Mind not found" }, 404);
   const body = await c.req.json();
-  if (!body.sender) return c.json({ error: "sender is required" }, 400);
-  addTrust(mindDir(name), body.sender);
-  return c.json({ ok: true });
-}).delete("/:name/files/trust/:sender", async (c) => {
-  const name = c.req.param("name");
-  if (!await findMind(name)) return c.json({ error: "Mind not found" }, 404);
-  const sender = c.req.param("sender");
-  removeTrust(mindDir(name), sender);
-  return c.json({ ok: true });
+  if (!body.sender || !body.filename || !body.data) {
+    return c.json({ error: "sender, filename, and data are required" }, 400);
+  }
+  const pathErr = validateFilePath(body.filename);
+  if (pathErr) return c.json({ error: pathErr }, 400);
+  const content = Buffer.from(body.data, "base64");
+  const MAX_FILE_SIZE2 = 50 * 1024 * 1024;
+  if (content.length > MAX_FILE_SIZE2) {
+    return c.json(
+      {
+        error: `File too large (${formatFileSize(content.length)}, max ${formatFileSize(MAX_FILE_SIZE2)})`
+      },
+      413
+    );
+  }
+  const sizeStr = formatFileSize(content.length);
+  const { id } = stageFile(receiverName, body.sender, body.filename, content, body.filename);
+  if (receiverEntry.running) {
+    await notifyMind(
+      receiverEntry.port,
+      `[file] ${body.sender} sent ${body.filename} (${sizeStr}) \u2014 run: volute chat accept ${id}`,
+      "system:file-sharing",
+      body.sender
+    );
+  }
+  return c.json({ status: "pending", id }, 200);
 });
 var file_sharing_default = app6;
 
 // src/web/api/files.ts
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import { readdir, readFile, realpath, stat } from "fs/promises";
-import { extname as extname2, resolve as resolve10 } from "path";
+import { extname as extname2, resolve as resolve9 } from "path";
 import { Hono as Hono7 } from "hono";
 var ALLOWED_FILES = /* @__PURE__ */ new Set(["SOUL.md", "MEMORY.md", "CLAUDE.md", "VOLUTE.md"]);
 var AVATAR_MIME2 = {
@@ -2692,8 +2564,8 @@ var app7 = new Hono7().get("/:name/avatar", async (c) => {
   const ext = extname2(config.profile.avatar).toLowerCase();
   const mime = AVATAR_MIME2[ext];
   if (!mime) return c.json({ error: "Invalid avatar extension" }, 400);
-  const homeDir = resolve10(dir, "home");
-  const avatarPath = resolve10(homeDir, config.profile.avatar);
+  const homeDir = resolve9(dir, "home");
+  const avatarPath = resolve9(homeDir, config.profile.avatar);
   if (!avatarPath.startsWith(`${homeDir}/`)) return c.json({ error: "Invalid avatar path" }, 400);
   let realAvatarPath;
   try {
@@ -2722,8 +2594,8 @@ var app7 = new Hono7().get("/:name/avatar", async (c) => {
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const dir = mindDir(name);
-  const homeDir = resolve10(dir, "home");
-  if (!existsSync9(homeDir)) return c.json({ error: "Home directory missing" }, 404);
+  const homeDir = resolve9(dir, "home");
+  if (!existsSync8(homeDir)) return c.json({ error: "Home directory missing" }, 404);
   const allFiles = await readdir(homeDir);
   const files = allFiles.filter((f) => f.endsWith(".md") && ALLOWED_FILES.has(f));
   return c.json(files);
@@ -2736,8 +2608,8 @@ var app7 = new Hono7().get("/:name/avatar", async (c) => {
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const dir = mindDir(name);
-  const filePath = resolve10(dir, "home", filename);
-  if (!existsSync9(filePath)) {
+  const filePath = resolve9(dir, "home", filename);
+  if (!existsSync8(filePath)) {
     return c.json({ error: "File not found" }, 404);
   }
   const content = await readFile(filePath, "utf-8");
@@ -2750,19 +2622,19 @@ import { Hono as Hono8 } from "hono";
 
 // src/lib/identity.ts
 import { createHash, generateKeyPairSync, sign, verify } from "crypto";
-import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
-import { resolve as resolve11 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve10 } from "path";
 function generateIdentity(mindDir2) {
-  const identityDir = resolve11(mindDir2, ".mind/identity");
-  mkdirSync6(identityDir, { recursive: true });
+  const identityDir = resolve10(mindDir2, ".mind/identity");
+  mkdirSync5(identityDir, { recursive: true });
   const { publicKey, privateKey } = generateKeyPairSync("ed25519", {
     publicKeyEncoding: { type: "spki", format: "pem" },
     privateKeyEncoding: { type: "pkcs8", format: "pem" }
   });
-  const privatePath = resolve11(identityDir, "private.pem");
-  const publicPath = resolve11(identityDir, "public.pem");
-  writeFileSync5(privatePath, privateKey, { mode: 384 });
-  writeFileSync5(publicPath, publicKey, { mode: 420 });
+  const privatePath = resolve10(identityDir, "private.pem");
+  const publicPath = resolve10(identityDir, "public.pem");
+  writeFileSync4(privatePath, privateKey, { mode: 384 });
+  writeFileSync4(publicPath, publicKey, { mode: 420 });
   const config = readVoluteConfig(mindDir2) ?? {};
   config.identity = {
     privateKey: ".mind/identity/private.pem",
@@ -2775,17 +2647,17 @@ function getPrivateKey(mindDir2) {
   const config = readVoluteConfig(mindDir2);
   const relPath = config?.identity?.privateKey;
   if (!relPath) return null;
-  const fullPath = resolve11(mindDir2, relPath);
-  if (!existsSync10(fullPath)) return null;
-  return readFileSync8(fullPath, "utf-8");
+  const fullPath = resolve10(mindDir2, relPath);
+  if (!existsSync9(fullPath)) return null;
+  return readFileSync7(fullPath, "utf-8");
 }
 function getPublicKey(mindDir2) {
   const config = readVoluteConfig(mindDir2);
   const relPath = config?.identity?.publicKey;
   if (!relPath) return null;
-  const fullPath = resolve11(mindDir2, relPath);
-  if (!existsSync10(fullPath)) return null;
-  return readFileSync8(fullPath, "utf-8");
+  const fullPath = resolve10(mindDir2, relPath);
+  if (!existsSync9(fullPath)) return null;
+  return readFileSync7(fullPath, "utf-8");
 }
 function getFingerprint(publicKeyPem) {
   return createHash("sha256").update(publicKeyPem).digest("hex");
@@ -2838,16 +2710,16 @@ var keys_default = app8;
 
 // src/web/api/logs.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync11 } from "fs";
-import { resolve as resolve12 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { resolve as resolve11 } from "path";
 import { Hono as Hono9 } from "hono";
 import { streamSSE as streamSSE2 } from "hono/streaming";
 var app9 = new Hono9().get("/:name/logs", async (c) => {
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const logFile = resolve12(stateDir(name), "logs", "mind.log");
-  if (!existsSync11(logFile)) {
+  const logFile = resolve11(stateDir(name), "logs", "mind.log");
+  if (!existsSync10(logFile)) {
     return c.json({ error: "No log file found" }, 404);
   }
   return streamSSE2(c, async (stream) => {
@@ -2865,17 +2737,17 @@ var app9 = new Hono9().get("/:name/logs", async (c) => {
     stream.onAbort(() => {
       tail.kill();
     });
-    await new Promise((resolve24) => {
-      tail.on("exit", resolve24);
-      stream.onAbort(resolve24);
+    await new Promise((resolve23) => {
+      tail.on("exit", resolve23);
+      stream.onAbort(resolve23);
     });
   });
 }).get("/:name/logs/tail", async (c) => {
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const logFile = resolve12(stateDir(name), "logs", "mind.log");
-  if (!existsSync11(logFile)) {
+  const logFile = resolve11(stateDir(name), "logs", "mind.log");
+  if (!existsSync10(logFile)) {
     return c.json({ error: "No log file found" }, 404);
   }
   const nParam = parseInt(c.req.query("n") ?? "50", 10);
@@ -2885,8 +2757,8 @@ var app9 = new Hono9().get("/:name/logs", async (c) => {
   tail.stdout.on("data", (data) => {
     output += data.toString();
   });
-  await new Promise((resolve24) => {
-    tail.on("exit", resolve24);
+  await new Promise((resolve23) => {
+    tail.on("exit", resolve23);
   });
   return c.text(output);
 });
@@ -2905,7 +2777,7 @@ var app10 = new Hono10().get("/:name/skills", async (c) => {
   return c.json(skills);
 }).post(
   "/:name/skills/install",
-  requireAdmin,
+  requireSelf(),
   zValidator3("json", z3.object({ skillId: z3.string() })),
   async (c) => {
     const name = c.req.param("name");
@@ -2923,7 +2795,7 @@ var app10 = new Hono10().get("/:name/skills", async (c) => {
   }
 ).post(
   "/:name/skills/update",
-  requireAdmin,
+  requireSelf(),
   zValidator3("json", z3.object({ skillId: z3.string() })),
   async (c) => {
     const name = c.req.param("name");
@@ -2941,7 +2813,7 @@ var app10 = new Hono10().get("/:name/skills", async (c) => {
   }
 ).post(
   "/:name/skills/publish",
-  requireAdmin,
+  requireSelf(),
   zValidator3("json", z3.object({ skillId: z3.string() })),
   async (c) => {
     const name = c.req.param("name");
@@ -2957,7 +2829,7 @@ var app10 = new Hono10().get("/:name/skills", async (c) => {
       return c.json({ error: msg }, 400);
     }
   }
-).delete("/:name/skills/:skill", requireAdmin, async (c) => {
+).delete("/:name/skills/:skill", requireSelf(), async (c) => {
   const name = c.req.param("name");
   const skillName = c.req.param("skill");
   const entry = await findMind(name);
@@ -2976,33 +2848,33 @@ var mind_skills_default = app10;
 // src/web/api/minds.ts
 import {
   cpSync,
-  existsSync as existsSync14,
-  mkdirSync as mkdirSync9,
-  readdirSync as readdirSync4,
-  readFileSync as readFileSync12,
-  rmSync as rmSync5,
-  writeFileSync as writeFileSync9
+  existsSync as existsSync13,
+  mkdirSync as mkdirSync8,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync11,
+  rmSync as rmSync4,
+  writeFileSync as writeFileSync8
 } from "fs";
-import { resolve as resolve16 } from "path";
+import { resolve as resolve15 } from "path";
 import { zValidator as zValidator4 } from "@hono/zod-validator";
-import { and as and2, desc as desc2, eq as eq3, sql } from "drizzle-orm";
+import { and as and3, desc as desc2, eq as eq4, sql } from "drizzle-orm";
 import { Hono as Hono11 } from "hono";
 import { z as z4 } from "zod";
 
 // src/lib/consolidate.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
-import { resolve as resolve13 } from "path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
+import { resolve as resolve12 } from "path";
 async function consolidateMemory(mindDir2) {
-  const soulPath = resolve13(mindDir2, "home/SOUL.md");
-  const memoryPath = resolve13(mindDir2, "home/MEMORY.md");
-  const memoryDir = resolve13(mindDir2, "home/memory");
-  const soul = readFileSync9(soulPath, "utf-8");
+  const soulPath = resolve12(mindDir2, "home/SOUL.md");
+  const memoryPath = resolve12(mindDir2, "home/MEMORY.md");
+  const memoryDir = resolve12(mindDir2, "home/memory");
+  const soul = readFileSync8(soulPath, "utf-8");
   const logs = [];
   try {
-    const files = readdirSync3(memoryDir).filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f)).sort();
+    const files = readdirSync2(memoryDir).filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f)).sort();
     for (const filename of files) {
       const date = filename.replace(".md", "");
-      const content2 = readFileSync9(resolve13(memoryDir, filename), "utf-8").trim();
+      const content2 = readFileSync8(resolve12(memoryDir, filename), "utf-8").trim();
       if (content2) {
         logs.push(`### ${date}
 
@@ -3052,7 +2924,7 @@ ${content2}`);
   const data = await res.json();
   const content = data.content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("").trim();
   if (content) {
-    writeFileSync6(memoryPath, `${content}
+    writeFileSync5(memoryPath, `${content}
 `);
     console.log("MEMORY.md created successfully.");
   } else {
@@ -3062,11 +2934,11 @@ ${content2}`);
 
 // src/lib/convert-session.ts
 import { randomUUID } from "crypto";
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "fs";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
 import { homedir } from "os";
-import { resolve as resolve14 } from "path";
+import { resolve as resolve13 } from "path";
 function convertSession(opts) {
-  const lines = readFileSync10(opts.sessionPath, "utf-8").trim().split("\n");
+  const lines = readFileSync9(opts.sessionPath, "utf-8").trim().split("\n");
   const sessionId = randomUUID();
   const idMap = /* @__PURE__ */ new Map();
   const messages = [];
@@ -3180,10 +3052,10 @@ function convertSession(opts) {
     }
   }
   const projectId = opts.projectDir.replace(/\//g, "-");
-  const sdkDir = resolve14(homedir(), ".claude", "projects", projectId);
-  mkdirSync7(sdkDir, { recursive: true });
-  const sdkPath = resolve14(sdkDir, `${sessionId}.jsonl`);
-  writeFileSync7(sdkPath, `${sdkEvents.join("\n")}
+  const sdkDir = resolve13(homedir(), ".claude", "projects", projectId);
+  mkdirSync6(sdkDir, { recursive: true });
+  const sdkPath = resolve13(sdkDir, `${sessionId}.jsonl`);
+  writeFileSync6(sdkPath, `${sdkEvents.join("\n")}
 `);
   console.log(`Converted ${sdkEvents.length} messages \u2192 ${sdkPath}`);
   return sessionId;
@@ -3249,7 +3121,7 @@ async function checkHealth(port) {
 }
 
 // src/lib/variant-cleanup.ts
-import { existsSync as existsSync12, rmSync as rmSync4 } from "fs";
+import { existsSync as existsSync11, rmSync as rmSync3 } from "fs";
 async function cleanupVariant(variantName, projectRoot, variantPath, opts) {
   if (opts?.stop) {
     try {
@@ -3261,11 +3133,11 @@ async function cleanupVariant(variantName, projectRoot, variantPath, opts) {
   const { findMind: findMind2 } = await import("./registry-NDNOOYG4.js");
   const variantEntry = await findMind2(variantName);
   const branchName = variantEntry?.branch ?? variantName;
-  if (existsSync12(variantPath)) {
+  if (existsSync11(variantPath)) {
     try {
       await gitExec(["worktree", "remove", "--force", variantPath], { cwd: projectRoot });
     } catch {
-      rmSync4(variantPath, { recursive: true, force: true });
+      rmSync3(variantPath, { recursive: true, force: true });
       try {
         await gitExec(["worktree", "prune"], { cwd: projectRoot });
       } catch (err) {
@@ -3295,8 +3167,8 @@ async function cleanupVariant(variantName, projectRoot, variantPath, opts) {
 }
 
 // src/lib/variants.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "fs";
-import { resolve as resolve15 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "fs";
+import { resolve as resolve14 } from "path";
 async function checkHealth2(port) {
   try {
     const res = await fetch(`http://127.0.0.1:${port}/health`, {
@@ -3325,8 +3197,8 @@ async function getMindStatus(name, port) {
   const manager = getMindManager();
   let status = "stopped";
   try {
-    const { getSleepManagerIfReady } = await import("./sleep-manager-MWYHM5HV.js");
-    if (getSleepManagerIfReady()?.isSleeping(name)) {
+    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G4B5GW5P.js");
+    if (getSleepManagerIfReady2()?.isSleeping(name)) {
       status = "sleeping";
     }
   } catch {
@@ -3373,7 +3245,7 @@ async function initTemplateBranch(projectRoot, composedDir, manifest, mindName,
   await gitExec(["commit", "-m", "initial commit"], opts);
 }
 async function updateTemplateBranch(projectRoot, template, mindName) {
-  const tempWorktree = resolve16(projectRoot, ".variants", "_template_update");
+  const tempWorktree = resolve15(projectRoot, ".variants", "_template_update");
   let branchExists = false;
   try {
     await gitExec(["rev-parse", "--verify", TEMPLATE_BRANCH], { cwd: projectRoot });
@@ -3384,8 +3256,8 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
     await gitExec(["worktree", "remove", "--force", tempWorktree], { cwd: projectRoot });
   } catch {
   }
-  if (existsSync14(tempWorktree)) {
-    rmSync5(tempWorktree, { recursive: true, force: true });
+  if (existsSync13(tempWorktree)) {
+    rmSync4(tempWorktree, { recursive: true, force: true });
   }
   const templatesRoot = findTemplatesRoot();
   const { composedDir, manifest } = composeTemplate(templatesRoot, template);
@@ -3405,9 +3277,9 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
       });
     }
     copyTemplateToDir(composedDir, tempWorktree, mindName, manifest);
-    const initDir = resolve16(tempWorktree, ".init");
-    if (existsSync14(initDir)) {
-      rmSync5(initDir, { recursive: true, force: true });
+    const initDir = resolve15(tempWorktree, ".init");
+    if (existsSync13(initDir)) {
+      rmSync4(initDir, { recursive: true, force: true });
     }
     await gitExec(["add", "-A"], { cwd: tempWorktree });
     try {
@@ -3420,10 +3292,10 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
       await gitExec(["worktree", "remove", "--force", tempWorktree], { cwd: projectRoot });
     } catch {
     }
-    if (existsSync14(tempWorktree)) {
-      rmSync5(tempWorktree, { recursive: true, force: true });
+    if (existsSync13(tempWorktree)) {
+      rmSync4(tempWorktree, { recursive: true, force: true });
     }
-    rmSync5(composedDir, { recursive: true, force: true });
+    rmSync4(composedDir, { recursive: true, force: true });
   }
 }
 async function mergeTemplateBranch(worktreeDir) {
@@ -3446,14 +3318,14 @@ async function mergeTemplateBranch(worktreeDir) {
 async function npmInstallAsMind(cwd, mindName) {
   if (isIsolationEnabled()) {
     const [cmd, args] = await wrapForIsolation("npm", ["install"], mindName);
-    await exec(cmd, args, { cwd, env: { ...process.env, HOME: resolve16(cwd, "home") } });
+    await exec(cmd, args, { cwd, env: { ...process.env, HOME: resolve15(cwd, "home") } });
   } else {
     await exec("npm", ["install"], { cwd });
   }
 }
 async function importFromArchive(c, tempDir, nameOverride, manifest) {
-  const extractedMindDir = resolve16(tempDir, "mind");
-  if (!existsSync14(extractedMindDir)) {
+  const extractedMindDir = resolve15(tempDir, "mind");
+  if (!existsSync13(extractedMindDir)) {
     return c.json({ error: "Invalid archive: missing mind/ directory" }, 400);
   }
   if (!manifest?.includes || !manifest.name || !manifest.template) {
@@ -3471,21 +3343,21 @@ async function importFromFullArchive(c, tempDir, extractedMindDir, nameOverride,
   if (await findMind(name)) return c.json({ error: `Mind already exists: ${name}` }, 409);
   ensureVoluteHome();
   const dest = mindDir(name);
-  if (existsSync14(dest)) return c.json({ error: "Mind directory already exists" }, 409);
+  if (existsSync13(dest)) return c.json({ error: "Mind directory already exists" }, 409);
   try {
     cpSync(extractedMindDir, dest, { recursive: true });
     if (!manifest.includes.identity) {
       generateIdentity(dest);
     }
     const state = stateDir(name);
-    mkdirSync9(state, { recursive: true });
-    const channelsJson = resolve16(tempDir, "state/channels.json");
-    if (existsSync14(channelsJson)) {
-      cpSync(channelsJson, resolve16(state, "channels.json"));
+    mkdirSync8(state, { recursive: true });
+    const channelsJson = resolve15(tempDir, "state/channels.json");
+    if (existsSync13(channelsJson)) {
+      cpSync(channelsJson, resolve15(state, "channels.json"));
     }
-    const envJson = resolve16(tempDir, "state/env.json");
-    if (existsSync14(envJson)) {
-      cpSync(envJson, resolve16(state, "env.json"));
+    const envJson = resolve15(tempDir, "state/env.json");
+    if (existsSync13(envJson)) {
+      cpSync(envJson, resolve15(state, "env.json"));
     }
     const port = await nextPort();
     await addMind(name, port, manifest.stage, manifest.template);
@@ -3494,36 +3366,36 @@ async function importFromFullArchive(c, tempDir, extractedMindDir, nameOverride,
     } catch (err) {
       logger_default.warn(`failed to set template hash for ${name}`, logger_default.errorData(err));
     }
-    const homeDir = resolve16(dest, "home");
+    const homeDir = resolve15(dest, "home");
     ensureVoluteGroup();
     createMindUser(name, homeDir);
     chownMindDir(dest, name);
     await npmInstallAsMind(dest, name);
     await importHistoryFromArchive(name, tempDir);
     importSessionsFromArchive(dest, tempDir);
-    if (!existsSync14(resolve16(dest, ".git"))) {
+    if (!existsSync13(resolve15(dest, ".git"))) {
       try {
-        const env = isIsolationEnabled() ? { ...process.env, HOME: resolve16(dest, "home") } : void 0;
+        const env = isIsolationEnabled() ? { ...process.env, HOME: resolve15(dest, "home") } : void 0;
         await gitExec(["init"], { cwd: dest, mindName: name, env });
         await configureGitIdentity(name, { cwd: dest, mindName: name, env });
         await gitExec(["add", "-A"], { cwd: dest, mindName: name, env });
         await gitExec(["commit", "-m", "import from archive"], { cwd: dest, mindName: name, env });
       } catch (err) {
         logger_default.error(`git setup failed for imported mind ${name}`, logger_default.errorData(err));
-        rmSync5(resolve16(dest, ".git"), { recursive: true, force: true });
+        rmSync4(resolve15(dest, ".git"), { recursive: true, force: true });
       }
     }
     chownMindDir(dest, name);
-    rmSync5(tempDir, { recursive: true, force: true });
+    rmSync4(tempDir, { recursive: true, force: true });
     return c.json({ ok: true, name, port, message: `Imported mind: ${name} (port ${port})` });
   } catch (err) {
-    if (existsSync14(dest)) rmSync5(dest, { recursive: true, force: true });
+    if (existsSync13(dest)) rmSync4(dest, { recursive: true, force: true });
     try {
       await removeMind(name);
     } catch (cleanupErr) {
       logger_default.error(`Failed to clean up registry for ${name}`, logger_default.errorData(cleanupErr));
     }
-    rmSync5(tempDir, { recursive: true, force: true });
+    rmSync4(tempDir, { recursive: true, force: true });
     return c.json({ error: err instanceof Error ? err.message : "Failed to import mind" }, 500);
   }
 }
@@ -3534,7 +3406,7 @@ async function importFromHomeOnlyArchive(c, tempDir, extractedMindDir, nameOverr
   if (await findMind(name)) return c.json({ error: `Mind already exists: ${name}` }, 409);
   ensureVoluteHome();
   const dest = mindDir(name);
-  if (existsSync14(dest)) return c.json({ error: "Mind directory already exists" }, 409);
+  if (existsSync13(dest)) return c.json({ error: "Mind directory already exists" }, 409);
   const templatesRoot = findTemplatesRoot();
   const { composedDir, manifest: templateManifest } = composeTemplate(
     templatesRoot,
@@ -3543,40 +3415,40 @@ async function importFromHomeOnlyArchive(c, tempDir, extractedMindDir, nameOverr
   try {
     copyTemplateToDir(composedDir, dest, name, templateManifest);
     applyInitFiles(dest);
-    const extractedHome = resolve16(extractedMindDir, "home");
-    if (existsSync14(extractedHome)) {
-      cpSync(extractedHome, resolve16(dest, "home"), { recursive: true });
+    const extractedHome = resolve15(extractedMindDir, "home");
+    if (existsSync13(extractedHome)) {
+      cpSync(extractedHome, resolve15(dest, "home"), { recursive: true });
     }
-    const extractedMindInternal = resolve16(extractedMindDir, ".mind");
-    if (existsSync14(extractedMindInternal)) {
-      cpSync(extractedMindInternal, resolve16(dest, ".mind"), { recursive: true });
+    const extractedMindInternal = resolve15(extractedMindDir, ".mind");
+    if (existsSync13(extractedMindInternal)) {
+      cpSync(extractedMindInternal, resolve15(dest, ".mind"), { recursive: true });
     }
-    const identityDir = resolve16(dest, ".mind/identity");
+    const identityDir = resolve15(dest, ".mind/identity");
     let publicKeyPem;
-    if (!manifest.includes.identity || !existsSync14(resolve16(identityDir, "private.pem"))) {
+    if (!manifest.includes.identity || !existsSync13(resolve15(identityDir, "private.pem"))) {
       ({ publicKeyPem } = generateIdentity(dest));
     } else {
-      publicKeyPem = readFileSync12(resolve16(identityDir, "public.pem"), "utf-8");
+      publicKeyPem = readFileSync11(resolve15(identityDir, "public.pem"), "utf-8");
     }
-    const promptsPath = resolve16(dest, "home/.config/prompts.json");
-    if (!existsSync14(promptsPath)) {
+    const promptsPath = resolve15(dest, "home/.config/prompts.json");
+    if (!existsSync13(promptsPath)) {
       const mindPrompts = await getMindPromptDefaults();
-      writeFileSync9(promptsPath, `${JSON.stringify(mindPrompts, null, 2)}
+      writeFileSync8(promptsPath, `${JSON.stringify(mindPrompts, null, 2)}
 `);
     }
     const state = stateDir(name);
-    mkdirSync9(state, { recursive: true });
-    const channelsJson = resolve16(tempDir, "state/channels.json");
-    if (existsSync14(channelsJson)) {
-      cpSync(channelsJson, resolve16(state, "channels.json"));
+    mkdirSync8(state, { recursive: true });
+    const channelsJson = resolve15(tempDir, "state/channels.json");
+    if (existsSync13(channelsJson)) {
+      cpSync(channelsJson, resolve15(state, "channels.json"));
     }
-    const envJson = resolve16(tempDir, "state/env.json");
-    if (existsSync14(envJson)) {
-      cpSync(envJson, resolve16(state, "env.json"));
+    const envJson = resolve15(tempDir, "state/env.json");
+    if (existsSync13(envJson)) {
+      cpSync(envJson, resolve15(state, "env.json"));
     }
     const port = await nextPort();
     await addMind(name, port, manifest.stage, manifest.template);
-    const homeDir = resolve16(dest, "home");
+    const homeDir = resolve15(dest, "home");
     ensureVoluteGroup();
     createMindUser(name, homeDir);
     chownMindDir(dest, name);
@@ -3589,7 +3461,7 @@ async function importFromHomeOnlyArchive(c, tempDir, extractedMindDir, nameOverr
       await initTemplateBranch(dest, composedDir, templateManifest, name, env);
     } catch (err) {
       logger_default.error(`git setup failed for imported mind ${name}`, logger_default.errorData(err));
-      rmSync5(resolve16(dest, ".git"), { recursive: true, force: true });
+      rmSync4(resolve15(dest, ".git"), { recursive: true, force: true });
       gitWarning = "Git setup failed \u2014 variants and upgrades won't be available until git is initialized.";
     }
     try {
@@ -3613,7 +3485,7 @@ async function importFromHomeOnlyArchive(c, tempDir, extractedMindDir, nameOverr
     publishPublicKey(name, publicKeyPem).catch(
       (err) => logger_default.warn(`failed to publish key for ${name}`, { error: err.message })
     );
-    rmSync5(tempDir, { recursive: true, force: true });
+    rmSync4(tempDir, { recursive: true, force: true });
     return c.json({
       ok: true,
       name,
@@ -3624,24 +3496,24 @@ async function importFromHomeOnlyArchive(c, tempDir, extractedMindDir, nameOverr
       ...skillWarnings.length > 0 && { skillWarnings }
     });
   } catch (err) {
-    if (existsSync14(dest)) rmSync5(dest, { recursive: true, force: true });
+    if (existsSync13(dest)) rmSync4(dest, { recursive: true, force: true });
     try {
       await removeMind(name);
     } catch (cleanupErr) {
       logger_default.error(`Failed to clean up registry for ${name}`, logger_default.errorData(cleanupErr));
     }
-    rmSync5(tempDir, { recursive: true, force: true });
+    rmSync4(tempDir, { recursive: true, force: true });
     return c.json({ error: err instanceof Error ? err.message : "Failed to import mind" }, 500);
   } finally {
-    rmSync5(composedDir, { recursive: true, force: true });
+    rmSync4(composedDir, { recursive: true, force: true });
   }
 }
 async function importHistoryFromArchive(name, tempDir) {
-  const historyJsonl = resolve16(tempDir, "history.jsonl");
-  if (!existsSync14(historyJsonl)) return;
+  const historyJsonl = resolve15(tempDir, "history.jsonl");
+  if (!existsSync13(historyJsonl)) return;
   try {
     const db = await getDb();
-    const lines = readFileSync12(historyJsonl, "utf-8").trim().split("\n");
+    const lines = readFileSync11(historyJsonl, "utf-8").trim().split("\n");
     let imported = 0;
     let failed = 0;
     for (const line of lines) {
@@ -3677,13 +3549,13 @@ async function importHistoryFromArchive(name, tempDir) {
   }
 }
 function importSessionsFromArchive(dest, tempDir) {
-  const sessionsDir = resolve16(tempDir, "sessions");
-  if (!existsSync14(sessionsDir)) return;
+  const sessionsDir = resolve15(tempDir, "sessions");
+  if (!existsSync13(sessionsDir)) return;
   try {
-    const destSessions = resolve16(dest, ".mind/sessions");
-    mkdirSync9(destSessions, { recursive: true });
-    for (const file of readdirSync4(sessionsDir)) {
-      cpSync(resolve16(sessionsDir, file), resolve16(destSessions, file));
+    const destSessions = resolve15(dest, ".mind/sessions");
+    mkdirSync8(destSessions, { recursive: true });
+    for (const file of readdirSync3(sessionsDir)) {
+      cpSync(resolve15(sessionsDir, file), resolve15(destSessions, file));
     }
   } catch (err) {
     logger_default.error("Failed to import sessions from archive", logger_default.errorData(err));
@@ -3706,7 +3578,7 @@ var app11 = new Hono11().post("/", requireAdmin, zValidator4("json", createMindS
   if (await findMind(name)) return c.json({ error: `Mind already exists: ${name}` }, 409);
   ensureVoluteHome();
   const dest = mindDir(name);
-  if (existsSync14(dest)) return c.json({ error: "Mind directory already exists" }, 409);
+  if (existsSync13(dest)) return c.json({ error: "Mind directory already exists" }, 409);
   const templatesRoot = findTemplatesRoot();
   const { composedDir, manifest } = composeTemplate(templatesRoot, template);
   try {
@@ -3739,15 +3611,15 @@ var app11 = new Hono11().post("/", requireAdmin, zValidator4("json", createMindS
       writeVoluteConfig(dest, config);
     }
     if (body.model) {
-      const configPath2 = resolve16(dest, "home/.config/config.json");
-      const existing = existsSync14(configPath2) ? JSON.parse(readFileSync12(configPath2, "utf-8")) : {};
+      const configPath = resolve15(dest, "home/.config/config.json");
+      const existing = existsSync13(configPath) ? JSON.parse(readFileSync11(configPath, "utf-8")) : {};
       existing.model = body.model;
-      writeFileSync9(configPath2, `${JSON.stringify(existing, null, 2)}
+      writeFileSync8(configPath, `${JSON.stringify(existing, null, 2)}
 `);
     }
     const mindPrompts = await getMindPromptDefaults();
-    writeFileSync9(
-      resolve16(dest, "home/.config/prompts.json"),
+    writeFileSync8(
+      resolve15(dest, "home/.config/prompts.json"),
       `${JSON.stringify(mindPrompts, null, 2)}
 `
     );
@@ -3758,7 +3630,7 @@ var app11 = new Hono11().post("/", requireAdmin, zValidator4("json", createMindS
     } catch (err) {
       logger_default.warn(`failed to set template hash for ${name}`, logger_default.errorData(err));
     }
-    const homeDir = resolve16(dest, "home");
+    const homeDir = resolve15(dest, "home");
     ensureVoluteGroup();
     createMindUser(name, homeDir);
     chownMindDir(dest, name);
@@ -3771,7 +3643,7 @@ var app11 = new Hono11().post("/", requireAdmin, zValidator4("json", createMindS
       await initTemplateBranch(dest, composedDir, manifest, name, env);
     } catch (err) {
       logger_default.error(`git setup failed for ${name}`, logger_default.errorData(err));
-      rmSync5(resolve16(dest, ".git"), { recursive: true, force: true });
+      rmSync4(resolve15(dest, ".git"), { recursive: true, force: true });
       gitWarning = "Git setup failed \u2014 variants and upgrades won't be available until git is initialized.";
     }
     try {
@@ -3786,7 +3658,7 @@ The human who planted you described you as: "${body.description}"
 ` : "";
       const seedSoulRaw = body.seedSoul ?? await getPrompt("seed_soul", { name, description: descLine });
       const seedSoul = body.seedSoul ? substitute(seedSoulRaw, { name, description: descLine }) : seedSoulRaw;
-      writeFileSync9(resolve16(dest, "home/SOUL.md"), seedSoul);
+      writeFileSync8(resolve15(dest, "home/SOUL.md"), seedSoul);
     }
     const skillSet = body.skills ?? (body.stage === "seed" ? SEED_SKILLS : STANDARD_SKILLS);
     const skillWarnings = [];
@@ -3801,11 +3673,11 @@ The human who planted you described you as: "${body.description}"
     if (body.stage !== "seed") {
       const customSoul = await getPromptIfCustom("default_soul");
       if (customSoul) {
-        writeFileSync9(resolve16(dest, "home/SOUL.md"), customSoul.replace(/\{\{name\}\}/g, name));
+        writeFileSync8(resolve15(dest, "home/SOUL.md"), customSoul.replace(/\{\{name\}\}/g, name));
       }
       const customMemory = await getPromptIfCustom("default_memory");
       if (customMemory) {
-        writeFileSync9(resolve16(dest, "home/MEMORY.md"), customMemory);
+        writeFileSync8(resolve15(dest, "home/MEMORY.md"), customMemory);
       }
     }
     publishPublicKey(name, publicKeyPem).catch(
@@ -3834,14 +3706,14 @@ The human who planted you described you as: "${body.description}"
       ...skillWarnings.length > 0 && { skillWarnings }
     });
   } catch (err) {
-    if (existsSync14(dest)) rmSync5(dest, { recursive: true, force: true });
+    if (existsSync13(dest)) rmSync4(dest, { recursive: true, force: true });
     try {
       await removeMind(name);
     } catch {
     }
     return c.json({ error: err instanceof Error ? err.message : "Failed to create mind" }, 500);
   } finally {
-    rmSync5(composedDir, { recursive: true, force: true });
+    rmSync4(composedDir, { recursive: true, force: true });
   }
 }).post("/import", requireAdmin, async (c) => {
   let body;
@@ -3854,13 +3726,13 @@ The human who planted you described you as: "${body.description}"
     return importFromArchive(c, body.archivePath, body.name, body.manifest);
   }
   const wsDir = body.workspacePath;
-  if (!wsDir || !existsSync14(resolve16(wsDir, "SOUL.md")) || !existsSync14(resolve16(wsDir, "IDENTITY.md"))) {
+  if (!wsDir || !existsSync13(resolve15(wsDir, "SOUL.md")) || !existsSync13(resolve15(wsDir, "IDENTITY.md"))) {
     return c.json({ error: "Invalid workspace: missing SOUL.md or IDENTITY.md" }, 400);
   }
-  const soul = readFileSync12(resolve16(wsDir, "SOUL.md"), "utf-8");
-  const identity = readFileSync12(resolve16(wsDir, "IDENTITY.md"), "utf-8");
-  const userPath = resolve16(wsDir, "USER.md");
-  const user = existsSync14(userPath) ? readFileSync12(userPath, "utf-8") : "";
+  const soul = readFileSync11(resolve15(wsDir, "SOUL.md"), "utf-8");
+  const identity = readFileSync11(resolve15(wsDir, "IDENTITY.md"), "utf-8");
+  const userPath = resolve15(wsDir, "USER.md");
+  const user = existsSync13(userPath) ? readFileSync11(userPath, "utf-8") : "";
   const name = body.name ?? parseNameFromIdentity(identity) ?? "imported-mind";
   const template = body.template ?? "claude";
   const nameErr = validateMindName(name);
@@ -3880,33 +3752,33 @@ ${user.trimEnd()}
 ` : "";
   ensureVoluteHome();
   const dest = mindDir(name);
-  if (existsSync14(dest)) return c.json({ error: "Mind directory already exists" }, 409);
+  if (existsSync13(dest)) return c.json({ error: "Mind directory already exists" }, 409);
   const templatesRoot = findTemplatesRoot();
   const { composedDir, manifest } = composeTemplate(templatesRoot, template);
   try {
     copyTemplateToDir(composedDir, dest, name, manifest);
     applyInitFiles(dest);
     const { publicKeyPem: importPublicKey } = generateIdentity(dest);
-    writeFileSync9(resolve16(dest, "home/SOUL.md"), mergedSoul);
-    const wsMemoryPath = resolve16(wsDir, "MEMORY.md");
-    const hasMemory = existsSync14(wsMemoryPath);
+    writeFileSync8(resolve15(dest, "home/SOUL.md"), mergedSoul);
+    const wsMemoryPath = resolve15(wsDir, "MEMORY.md");
+    const hasMemory = existsSync13(wsMemoryPath);
     if (hasMemory) {
-      const existingMemory = readFileSync12(wsMemoryPath, "utf-8");
-      writeFileSync9(
-        resolve16(dest, "home/MEMORY.md"),
+      const existingMemory = readFileSync11(wsMemoryPath, "utf-8");
+      writeFileSync8(
+        resolve15(dest, "home/MEMORY.md"),
         `${existingMemory.trimEnd()}${mergedMemoryExtra}`
       );
     } else if (user) {
-      writeFileSync9(resolve16(dest, "home/MEMORY.md"), `${user.trimEnd()}
+      writeFileSync8(resolve15(dest, "home/MEMORY.md"), `${user.trimEnd()}
 `);
     }
-    const wsMemoryDir = resolve16(wsDir, "memory");
+    const wsMemoryDir = resolve15(wsDir, "memory");
     let dailyLogCount = 0;
-    if (existsSync14(wsMemoryDir)) {
-      const destMemoryDir = resolve16(dest, "home/memory");
-      const files = readdirSync4(wsMemoryDir).filter((f) => f.endsWith(".md"));
+    if (existsSync13(wsMemoryDir)) {
+      const destMemoryDir = resolve15(dest, "home/memory");
+      const files = readdirSync3(wsMemoryDir).filter((f) => f.endsWith(".md"));
       for (const file of files) {
-        cpSync(resolve16(wsMemoryDir, file), resolve16(destMemoryDir, file));
+        cpSync(resolve15(wsMemoryDir, file), resolve15(destMemoryDir, file));
       }
       dailyLogCount = files.length;
     }
@@ -3917,7 +3789,7 @@ ${user.trimEnd()}
     } catch (err) {
       logger_default.warn(`failed to set template hash for ${name}`, logger_default.errorData(err));
     }
-    const homeDir = resolve16(dest, "home");
+    const homeDir = resolve15(dest, "home");
     ensureVoluteGroup();
     createMindUser(name, homeDir);
     chownMindDir(dest, name);
@@ -3925,20 +3797,20 @@ ${user.trimEnd()}
     if (!hasMemory && dailyLogCount > 0) {
       await consolidateMemory(dest);
     }
-    const env = isIsolationEnabled() ? { ...process.env, HOME: resolve16(dest, "home") } : void 0;
+    const env = isIsolationEnabled() ? { ...process.env, HOME: resolve15(dest, "home") } : void 0;
     await gitExec(["init"], { cwd: dest, mindName: name, env });
     await configureGitIdentity(name, { cwd: dest, mindName: name, env });
     await gitExec(["add", "-A"], { cwd: dest, mindName: name, env });
     await gitExec(["commit", "-m", "import from OpenClaw"], { cwd: dest, mindName: name, env });
-    const sessionFile = body.sessionPath ? resolve16(body.sessionPath) : findOpenClawSession(wsDir);
-    if (sessionFile && existsSync14(sessionFile)) {
+    const sessionFile = body.sessionPath ? resolve15(body.sessionPath) : findOpenClawSession(wsDir);
+    if (sessionFile && existsSync13(sessionFile)) {
       if (template === "pi") {
         importPiSession(sessionFile, dest);
       } else if (template === "claude") {
         const sessionId = convertSession({ sessionPath: sessionFile, projectDir: dest });
-        const mindRuntimeDir = resolve16(dest, ".mind");
-        mkdirSync9(mindRuntimeDir, { recursive: true });
-        writeFileSync9(resolve16(mindRuntimeDir, "session.json"), JSON.stringify({ sessionId }));
+        const mindRuntimeDir = resolve15(dest, ".mind");
+        mkdirSync8(mindRuntimeDir, { recursive: true });
+        writeFileSync8(resolve15(mindRuntimeDir, "session.json"), JSON.stringify({ sessionId }));
       }
     }
     importOpenClawConnectors(name, dest);
@@ -3953,14 +3825,14 @@ ${user.trimEnd()}
     );
     return c.json({ ok: true, name, port, message: `Imported mind: ${name} (port ${port})` });
   } catch (err) {
-    if (existsSync14(dest)) rmSync5(dest, { recursive: true, force: true });
+    if (existsSync13(dest)) rmSync4(dest, { recursive: true, force: true });
     try {
       await removeMind(name);
     } catch {
     }
     return c.json({ error: err instanceof Error ? err.message : "Failed to import mind" }, 500);
   } finally {
-    rmSync5(composedDir, { recursive: true, force: true });
+    rmSync4(composedDir, { recursive: true, force: true });
   }
 }).get("/", async (c) => {
   const entries = await readRegistry();
@@ -3977,7 +3849,7 @@ ${user.trimEnd()}
   const minds = await Promise.all(
     entries.map(async (entry) => {
       const mindStatus = await getMindStatus(entry.name, entry.port);
-      const hasPages = existsSync14(resolve16(mindDir(entry.name), "home", "public", "pages"));
+      const hasPages = existsSync13(resolve15(mindDir(entry.name), "home", "public", "pages"));
       return {
         ...entry,
         ...mindStatus,
@@ -3996,7 +3868,7 @@ ${user.trimEnd()}
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const dir = entry.dir ?? mindDir(entry.parent ?? name);
-  if (!existsSync14(dir)) return c.json({ error: "Mind directory missing" }, 404);
+  if (!existsSync13(dir)) return c.json({ error: "Mind directory missing" }, 404);
   const mindStatus = await getMindStatus(name, entry.port);
   const variants = await findVariants(name);
   const manager = getMindManager();
@@ -4010,9 +3882,9 @@ ${user.trimEnd()}
       return { name: s.name, port: s.port, status: variantStatus };
     })
   );
-  const hasPages = existsSync14(resolve16(mindDir(name), "home", "public", "pages"));
+  const hasPages = existsSync13(resolve15(mindDir(name), "home", "public", "pages"));
   return c.json({ ...entry, ...mindStatus, variants: variantStatuses, hasPages });
-}).post("/:name/start", requireAdmin, async (c) => {
+}).post("/:name/start", requireSelf(), async (c) => {
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
@@ -4021,7 +3893,7 @@ ${user.trimEnd()}
     if (!entry.dir) return c.json({ error: `Variant ${name} has no directory` }, 404);
   } else {
     const dir = mindDir(name);
-    if (!existsSync14(dir)) return c.json({ error: "Mind directory missing" }, 404);
+    if (!existsSync13(dir)) return c.json({ error: "Mind directory missing" }, 404);
   }
   if (getMindManager().isRunning(name)) {
     return c.json({ error: "Mind already running" }, 409);
@@ -4042,7 +3914,7 @@ ${user.trimEnd()}
     if (!entry.dir) return c.json({ error: `Variant ${name} has no directory` }, 404);
   } else {
     const dir = mindDir(name);
-    if (!existsSync14(dir)) return c.json({ error: "Mind directory missing" }, 404);
+    if (!existsSync13(dir)) return c.json({ error: "Mind directory missing" }, 404);
   }
   let context;
   const contentType = c.req.header("content-type");
@@ -4057,8 +3929,8 @@ ${user.trimEnd()}
   const manager = getMindManager();
   try {
     if (context?.type === "reload") {
-      const { getSleepManagerIfReady } = await import("./sleep-manager-MWYHM5HV.js");
-      const sleepState = getSleepManagerIfReady()?.getState(name);
+      const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G4B5GW5P.js");
+      const sleepState = getSleepManagerIfReady2()?.getState(name);
       if (sleepState?.sleeping) {
         logger_default.info(`skipping reload for ${name} during sleep \u2014 will apply on next wake`);
         return c.json({ ok: true, deferred: true, port: targetPort });
@@ -4077,7 +3949,7 @@ ${user.trimEnd()}
       const variantEntry = await findMind(mergeVariantName);
       if (variantEntry && variantEntry.parent === baseName && variantEntry.dir && variantEntry.branch) {
         const projectRoot = mindDir(baseName);
-        if (existsSync14(variantEntry.dir)) {
+        if (existsSync13(variantEntry.dir)) {
           const status = (await gitExec(["status", "--porcelain"], { cwd: variantEntry.dir })).trim();
           if (status) {
             try {
@@ -4119,7 +3991,7 @@ ${user.trimEnd()}
     if (context?.type === "sprouted" && !entry.parent) {
       try {
         const db = await getDb();
-        const activeConvs = await db.select({ id: conversations.id }).from(conversations).where(eq3(conversations.mind_name, baseName)).all();
+        const activeConvs = await db.select({ id: conversations.id }).from(conversations).where(eq4(conversations.mind_name, baseName)).all();
         for (const conv of activeConvs) {
           await addMessage(conv.id, "assistant", "system", [
             { type: "text", text: "[seed has sprouted]" }
@@ -4134,7 +4006,7 @@ ${user.trimEnd()}
   } catch (err) {
     return c.json({ error: err instanceof Error ? err.message : "Failed to restart mind" }, 500);
   }
-}).post("/:name/stop", requireAdmin, async (c) => {
+}).post("/:name/stop", requireSelf(), async (c) => {
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
@@ -4148,20 +4020,20 @@ ${user.trimEnd()}
   } catch (err) {
     return c.json({ error: err instanceof Error ? err.message : "Failed to stop mind" }, 500);
   }
-}).get("/:name/sleep", requireAdmin, async (c) => {
+}).get("/:name/sleep", requireSelf(), async (c) => {
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const { getSleepManagerIfReady } = await import("./sleep-manager-MWYHM5HV.js");
-  const sm = getSleepManagerIfReady();
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G4B5GW5P.js");
+  const sm = getSleepManagerIfReady2();
   if (!sm) return c.json({ error: "Sleep manager not initialized" }, 503);
   return c.json(sm.getState(name));
-}).post("/:name/sleep", requireAdmin, async (c) => {
+}).post("/:name/sleep", requireSelf(), async (c) => {
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const { getSleepManagerIfReady } = await import("./sleep-manager-MWYHM5HV.js");
-  const sm = getSleepManagerIfReady();
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G4B5GW5P.js");
+  const sm = getSleepManagerIfReady2();
   if (!sm) return c.json({ error: "Sleep manager not initialized" }, 503);
   if (sm.isSleeping(name)) return c.json({ error: "Mind is already sleeping" }, 409);
   const body = await c.req.json().catch(() => ({}));
@@ -4176,12 +4048,12 @@ ${user.trimEnd()}
     (err) => logger_default.error(`failed to initiate sleep for ${name}`, logger_default.errorData(err))
   );
   return c.json({ ok: true });
-}).post("/:name/wake", requireAdmin, async (c) => {
+}).post("/:name/wake", requireSelf(), async (c) => {
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const { getSleepManagerIfReady } = await import("./sleep-manager-MWYHM5HV.js");
-  const sm = getSleepManagerIfReady();
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G4B5GW5P.js");
+  const sm = getSleepManagerIfReady2();
   if (!sm) return c.json({ error: "Sleep manager not initialized" }, 503);
   const sleepState = sm.getState(name);
   if (!sleepState.sleeping) return c.json({ error: "Mind is not sleeping" }, 409);
@@ -4191,16 +4063,16 @@ ${user.trimEnd()}
     sm.initiateWake(name).catch((err) => logger_default.error(`failed to wake ${name}`, logger_default.errorData(err)));
   }
   return c.json({ ok: true });
-}).post("/:name/sleep/messages", requireAdmin, async (c) => {
+}).post("/:name/sleep/messages", requireSelf(), async (c) => {
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const { getSleepManagerIfReady } = await import("./sleep-manager-MWYHM5HV.js");
-  const sm = getSleepManagerIfReady();
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G4B5GW5P.js");
+  const sm = getSleepManagerIfReady2();
   if (!sm) return c.json({ error: "Sleep manager not initialized" }, 503);
   const flushed = await sm.flushQueuedMessages(name);
   return c.json({ ok: true, flushed });
-}).post("/:name/sprout", requireAdmin, async (c) => {
+}).post("/:name/sprout", requireSelf(), async (c) => {
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
@@ -4233,11 +4105,11 @@ ${user.trimEnd()}
   await removeMind(name);
   await deleteMindUser2(name);
   const state = stateDir(name);
-  if (existsSync14(state)) {
-    rmSync5(state, { recursive: true, force: true });
+  if (existsSync13(state)) {
+    rmSync4(state, { recursive: true, force: true });
   }
-  if (force && existsSync14(dir)) {
-    rmSync5(dir, { recursive: true, force: true });
+  if (force && existsSync13(dir)) {
+    rmSync4(dir, { recursive: true, force: true });
     deleteMindUser(name);
   }
   fireWebhook({
@@ -4246,12 +4118,12 @@ ${user.trimEnd()}
     data: { port: entry.port, stage: entry.stage, template: entry.template }
   });
   return c.json({ ok: true });
-}).post("/:name/upgrade", requireAdmin, async (c) => {
+}).post("/:name/upgrade", requireSelf(), async (c) => {
   const mindName = c.req.param("name");
   const entry = await findMind(mindName);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const dir = mindDir(mindName);
-  if (!existsSync14(dir)) return c.json({ error: "Mind directory missing" }, 404);
+  if (!existsSync13(dir)) return c.json({ error: "Mind directory missing" }, 404);
   let body = {};
   try {
     body = await c.req.json();
@@ -4260,16 +4132,16 @@ ${user.trimEnd()}
   const template = body.template ?? entry.template ?? "claude";
   const UPGRADE_BRANCH = "upgrade";
   const upgradeVariantName = `${mindName}-upgrade`;
-  const worktreeDir = resolve16(dir, ".variants", UPGRADE_BRANCH);
+  const worktreeDir = resolve15(dir, ".variants", UPGRADE_BRANCH);
   if (body.abort) {
-    if (!existsSync14(worktreeDir)) {
+    if (!existsSync13(worktreeDir)) {
       return c.json({ error: "No upgrade in progress" }, 400);
     }
     try {
       try {
-        const gitDirContent = readFileSync12(resolve16(worktreeDir, ".git"), "utf-8").trim();
+        const gitDirContent = readFileSync11(resolve15(worktreeDir, ".git"), "utf-8").trim();
         const gitDir = gitDirContent.replace("gitdir: ", "");
-        if (existsSync14(resolve16(gitDir, "MERGE_HEAD"))) {
+        if (existsSync13(resolve15(gitDir, "MERGE_HEAD"))) {
           await gitExec(["merge", "--abort"], { cwd: worktreeDir });
         }
       } catch {
@@ -4288,7 +4160,7 @@ ${user.trimEnd()}
     }
   }
   if (body.continue) {
-    if (!existsSync14(worktreeDir)) {
+    if (!existsSync13(worktreeDir)) {
       return c.json({ error: "No upgrade in progress" }, 400);
     }
     const status = await gitExec(["status", "--porcelain"], { cwd: worktreeDir });
@@ -4327,7 +4199,7 @@ ${user.trimEnd()}
     }
   }
   if (body.accept) {
-    if (!existsSync14(worktreeDir)) {
+    if (!existsSync13(worktreeDir)) {
       return c.json({ error: "No upgrade in progress" }, 400);
     }
     const variantEntry = await findMind(upgradeVariantName);
@@ -4341,7 +4213,7 @@ ${user.trimEnd()}
         await gitExec(["commit", "-m", "Auto-commit before upgrade merge"], {
           cwd: worktreeDir
         });
-      } catch (e) {
+      } catch {
         return c.json({ error: "Failed to auto-commit upgrade changes before merge" }, 500);
       }
     }
@@ -4385,22 +4257,22 @@ ${user.trimEnd()}
     }
     return c.json({ ok: true });
   }
-  if (existsSync14(worktreeDir)) {
+  if (existsSync13(worktreeDir)) {
     return c.json(
       { error: "Upgrade variant already exists. Use continue or delete it first." },
       409
     );
   }
-  if (!existsSync14(resolve16(dir, ".git"))) {
+  if (!existsSync13(resolve15(dir, ".git"))) {
     try {
-      const env = isIsolationEnabled() ? { ...process.env, HOME: resolve16(dir, "home") } : void 0;
+      const env = isIsolationEnabled() ? { ...process.env, HOME: resolve15(dir, "home") } : void 0;
       await gitExec(["init"], { cwd: dir, mindName, env });
       await configureGitIdentity(mindName, { cwd: dir, mindName, env });
       await gitExec(["add", "-A"], { cwd: dir, mindName, env });
       await gitExec(["commit", "-m", "initial commit"], { cwd: dir, mindName, env });
       chownMindDir(dir, mindName);
     } catch (err) {
-      rmSync5(resolve16(dir, ".git"), { recursive: true, force: true });
+      rmSync4(resolve15(dir, ".git"), { recursive: true, force: true });
       return c.json(
         {
           error: `Git initialization failed: ${err instanceof Error ? err.message : String(err)}`
@@ -4414,7 +4286,7 @@ ${user.trimEnd()}
     await gitExec(["branch", "-D", UPGRADE_BRANCH], { cwd: dir });
   } catch {
   }
-  if (!existsSync14(resolve16(dir, "home", "shared"))) {
+  if (!existsSync13(resolve15(dir, "home", "shared"))) {
     try {
       await addSharedWorktree(mindName, dir);
     } catch (err) {
@@ -4425,9 +4297,9 @@ ${user.trimEnd()}
     }
   }
   await updateTemplateBranch(dir, template, mindName);
-  const parentDir = resolve16(dir, ".variants");
-  if (!existsSync14(parentDir)) {
-    mkdirSync9(parentDir, { recursive: true });
+  const parentDir = resolve15(dir, ".variants");
+  if (!existsSync13(parentDir)) {
+    mkdirSync8(parentDir, { recursive: true });
   }
   await gitExec(["worktree", "add", "-b", UPGRADE_BRANCH, worktreeDir], { cwd: dir });
   const hasConflicts = await mergeTemplateBranch(worktreeDir);
@@ -4464,8 +4336,8 @@ ${user.trimEnd()}
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const baseName = entry.parent ?? name;
   try {
-    const { getSleepManagerIfReady } = await import("./sleep-manager-MWYHM5HV.js");
-    const sm = getSleepManagerIfReady();
+    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G4B5GW5P.js");
+    const sm = getSleepManagerIfReady2();
     if (sm?.isSleeping(baseName)) {
       const body2 = await c.req.text();
       let parsed2 = null;
@@ -4562,7 +4434,7 @@ ${user.trimEnd()}
   if (seedEntry?.stage === "seed") {
     try {
       const db = await getDb();
-      const countResult = await db.select({ count: sql`count(*)` }).from(mindHistory).where(eq3(mindHistory.mind, baseName));
+      const countResult = await db.select({ count: sql`count(*)` }).from(mindHistory).where(eq4(mindHistory.mind, baseName));
       const msgCount = countResult[0]?.count ?? 0;
       if (msgCount >= 10 && msgCount % 10 === 0) {
         const nudge = "\n[You've been exploring for a while. Whenever you feel ready, write your SOUL.md and MEMORY.md, then run volute mind sprout.]";
@@ -4596,6 +4468,34 @@ ${user.trimEnd()}
     logger_default.error(`delivery failed for ${name}`, logger_default.errorData(err));
   });
   return c.json({ ok: true });
+}).get("/:name/conversations", async (c) => {
+  const name = c.req.param("name");
+  const entry = await findMind(name);
+  if (!entry) return c.json({ error: "Mind not found" }, 404);
+  const convs = await listConversationsForMind(name);
+  return c.json(convs);
+}).get("/:name/conversations/:convId/messages", async (c) => {
+  const name = c.req.param("name");
+  const convId = c.req.param("convId");
+  const entry = await findMind(name);
+  if (!entry) return c.json({ error: "Mind not found" }, 404);
+  const belongs = await isConversationForMind(name, convId);
+  if (!belongs) {
+    return c.json({ error: "Conversation not found" }, 404);
+  }
+  const beforeStr = c.req.query("before");
+  const limitStr = c.req.query("limit");
+  if (!beforeStr && !limitStr) {
+    const msgs = await getMessages(convId);
+    return c.json({ items: msgs, hasMore: false });
+  }
+  const before = beforeStr ? parseInt(beforeStr, 10) : void 0;
+  const limit = limitStr ? parseInt(limitStr, 10) : void 0;
+  if (before !== void 0 && isNaN(before) || limit !== void 0 && isNaN(limit)) {
+    return c.json({ error: "Invalid pagination parameters" }, 400);
+  }
+  const result = await getMessagesPaginated(convId, { before, limit });
+  return c.json({ items: result.messages, hasMore: result.hasMore });
 }).get("/:name/budget", async (c) => {
   const name = c.req.param("name");
   const baseName = await getBaseName(name);
@@ -4607,13 +4507,13 @@ ${user.trimEnd()}
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const dir = mindDir(name);
-  if (!existsSync14(dir)) return c.json({ error: "Mind directory missing" }, 404);
+  if (!existsSync13(dir)) return c.json({ error: "Mind directory missing" }, 404);
   let config = readVoluteConfig(dir);
   if (!config && entry.template === "pi") {
-    const piConfigPath = resolve16(dir, "home/.config/config.json");
-    if (existsSync14(piConfigPath)) {
+    const piConfigPath = resolve15(dir, "home/.config/config.json");
+    if (existsSync13(piConfigPath)) {
       try {
-        config = JSON.parse(readFileSync12(piConfigPath, "utf-8"));
+        config = JSON.parse(readFileSync11(piConfigPath, "utf-8"));
       } catch {
       }
     }
@@ -4635,7 +4535,7 @@ ${user.trimEnd()}
   });
 }).put(
   "/:name/config",
-  requireAdmin,
+  requireSelf(),
   zValidator4(
     "json",
     z4.object({
@@ -4650,7 +4550,7 @@ ${user.trimEnd()}
     const entry = await findMind(name);
     if (!entry) return c.json({ error: "Mind not found" }, 404);
     const dir = mindDir(name);
-    if (!existsSync14(dir)) return c.json({ error: "Mind directory missing" }, 404);
+    if (!existsSync13(dir)) return c.json({ error: "Mind directory missing" }, 404);
     const body = c.req.valid("json");
     const existing = readVoluteConfig(dir) ?? {};
     if (body.model !== void 0) existing.model = body.model;
@@ -4835,18 +4735,18 @@ ${user.trimEnd()}
     event_count: sql`COUNT(*)`,
     message_count: sql`SUM(CASE WHEN ${mindHistory.type} IN ('inbound','outbound') THEN 1 ELSE 0 END)`,
     tool_count: sql`SUM(CASE WHEN ${mindHistory.type}='tool_use' THEN 1 ELSE 0 END)`
-  }).from(mindHistory).where(and2(eq3(mindHistory.mind, name), sql`${mindHistory.session} IS NOT NULL`)).groupBy(mindHistory.session).orderBy(sql`MIN(${mindHistory.created_at}) DESC`);
+  }).from(mindHistory).where(and3(eq4(mindHistory.mind, name), sql`${mindHistory.session} IS NOT NULL`)).groupBy(mindHistory.session).orderBy(sql`MIN(${mindHistory.created_at}) DESC`);
   return c.json(rows);
 }).get("/:name/history/channels", async (c) => {
   const name = c.req.param("name");
   const db = await getDb();
-  const rows = await db.selectDistinct({ channel: mindHistory.channel }).from(mindHistory).where(eq3(mindHistory.mind, name));
+  const rows = await db.selectDistinct({ channel: mindHistory.channel }).from(mindHistory).where(eq4(mindHistory.mind, name));
   return c.json(rows.map((r) => r.channel));
 }).get("/:name/history/export", async (c) => {
   const name = c.req.param("name");
   if (!await findMind(name)) return c.json({ error: "Mind not found" }, 404);
   const db = await getDb();
-  const rows = await db.select().from(mindHistory).where(eq3(mindHistory.mind, name));
+  const rows = await db.select().from(mindHistory).where(eq4(mindHistory.mind, name));
   return c.json(rows);
 }).get("/:name/history", async (c) => {
   const name = c.req.param("name");
@@ -4856,17 +4756,17 @@ ${user.trimEnd()}
   const limit = Math.min(Math.max(parseInt(c.req.query("limit") ?? "50", 10) || 50, 1), 200);
   const offset = Math.max(parseInt(c.req.query("offset") ?? "0", 10) || 0, 0);
   const db = await getDb();
-  const conditions = [eq3(mindHistory.mind, name)];
+  const conditions = [eq4(mindHistory.mind, name)];
   if (channel) {
-    conditions.push(eq3(mindHistory.channel, channel));
+    conditions.push(eq4(mindHistory.channel, channel));
   }
   if (session) {
-    conditions.push(eq3(mindHistory.session, session));
+    conditions.push(eq4(mindHistory.session, session));
   }
   if (!full) {
     conditions.push(sql`${mindHistory.type} IN ('inbound', 'outbound')`);
   }
-  const rows = await db.select().from(mindHistory).where(and2(...conditions)).orderBy(desc2(mindHistory.created_at)).limit(limit).offset(offset);
+  const rows = await db.select().from(mindHistory).where(and3(...conditions)).orderBy(desc2(mindHistory.created_at)).limit(limit).offset(offset);
   return c.json(rows);
 });
 var minds_default = app11;
@@ -4877,11 +4777,11 @@ import { Hono as Hono12 } from "hono";
 import { z as z5 } from "zod";
 
 // src/lib/notes.ts
-import { and as and3, count, desc as desc3, eq as eq4, inArray, sql as sql2 } from "drizzle-orm";
+import { and as and4, count, desc as desc3, eq as eq5, inArray, sql as sql2 } from "drizzle-orm";
 async function createNote(authorId, title, content, replyToId) {
   const db = await getDb();
   let slug = slugify(title) || "untitled";
-  const existing = await db.select({ slug: notes.slug }).from(notes).where(eq4(notes.author_id, authorId)).all();
+  const existing = await db.select({ slug: notes.slug }).from(notes).where(eq5(notes.author_id, authorId)).all();
   const existingSlugs = new Set(existing.map((r) => r.slug));
   if (existingSlugs.has(slug)) {
     let i = 2;
@@ -4889,7 +4789,7 @@ async function createNote(authorId, title, content, replyToId) {
     slug = `${slug}-${i}`;
   }
   const [row] = await db.insert(notes).values({ author_id: authorId, title, slug, content, reply_to_id: replyToId ?? null }).returning();
-  const author = await db.select().from(users).where(eq4(users.id, authorId)).get();
+  const author = await db.select().from(users).where(eq5(users.id, authorId)).get();
   return {
     ...row,
     author_username: author?.username ?? "unknown",
@@ -4910,7 +4810,7 @@ async function getNote(authorUsername, slug) {
     updated_at: notes.updated_at,
     author_username: users.username,
     author_display_name: users.display_name
-  }).from(notes).innerJoin(users, eq4(notes.author_id, users.id)).where(and3(eq4(users.username, authorUsername), eq4(notes.slug, slug))).get();
+  }).from(notes).innerJoin(users, eq5(notes.author_id, users.id)).where(and4(eq5(users.username, authorUsername), eq5(notes.slug, slug))).get();
   if (!row) return null;
   const comments = await getComments(row.id);
   const reactions = await getReactions(row.id);
@@ -4920,7 +4820,7 @@ async function getNote(authorUsername, slug) {
       title: notes.title,
       slug: notes.slug,
       author_username: users.username
-    }).from(notes).innerJoin(users, eq4(notes.author_id, users.id)).where(eq4(notes.id, row.reply_to_id)).get();
+    }).from(notes).innerJoin(users, eq5(notes.author_id, users.id)).where(eq5(notes.id, row.reply_to_id)).get();
     if (parent) {
       reply_to = parent;
     }
@@ -4930,7 +4830,7 @@ async function getNote(authorUsername, slug) {
     slug: notes.slug,
     title: notes.title,
     created_at: notes.created_at
-  }).from(notes).innerJoin(users, eq4(notes.author_id, users.id)).where(eq4(notes.reply_to_id, row.id)).orderBy(notes.created_at).all();
+  }).from(notes).innerJoin(users, eq5(notes.author_id, users.id)).where(eq5(notes.reply_to_id, row.id)).orderBy(notes.created_at).all();
   return { ...row, comment_count: comments.length, comments, reactions, reply_to, replies };
 }
 async function listNotes(opts) {
@@ -4939,7 +4839,7 @@ async function listNotes(opts) {
   const offset = opts?.offset ?? 0;
   const conditions = [];
   if (opts?.authorUsername) {
-    conditions.push(eq4(users.username, opts.authorUsername));
+    conditions.push(eq5(users.username, opts.authorUsername));
   }
   const rows = await db.select({
     id: notes.id,
@@ -4952,7 +4852,7 @@ async function listNotes(opts) {
     updated_at: notes.updated_at,
     author_username: users.username,
     author_display_name: users.display_name
-  }).from(notes).innerJoin(users, eq4(notes.author_id, users.id)).where(conditions.length > 0 ? and3(...conditions) : void 0).orderBy(desc3(notes.created_at)).limit(limit).offset(offset).all();
+  }).from(notes).innerJoin(users, eq5(notes.author_id, users.id)).where(conditions.length > 0 ? and4(...conditions) : void 0).orderBy(desc3(notes.created_at)).limit(limit).offset(offset).all();
   const noteIds = rows.map((r) => r.id);
   if (noteIds.length === 0) return [];
   const commentCounts = await db.select({
@@ -4978,7 +4878,7 @@ async function listNotes(opts) {
       title: notes.title,
       slug: notes.slug,
       author_username: users.username
-    }).from(notes).innerJoin(users, eq4(notes.author_id, users.id)).where(inArray(notes.id, replyToIds)).all();
+    }).from(notes).innerJoin(users, eq5(notes.author_id, users.id)).where(inArray(notes.id, replyToIds)).all();
     for (const parent of parents) {
       replyToMap.set(parent.id, {
         author_username: parent.author_username,
@@ -5000,12 +4900,12 @@ async function listNotes(opts) {
 }
 async function updateNote(authorUsername, slug, updates) {
   const db = await getDb();
-  const existing = await db.select({ id: notes.id, author_id: notes.author_id }).from(notes).innerJoin(users, eq4(notes.author_id, users.id)).where(and3(eq4(users.username, authorUsername), eq4(notes.slug, slug))).get();
+  const existing = await db.select({ id: notes.id, author_id: notes.author_id }).from(notes).innerJoin(users, eq5(notes.author_id, users.id)).where(and4(eq5(users.username, authorUsername), eq5(notes.slug, slug))).get();
   if (!existing) return null;
   const set = { updated_at: sql2`(datetime('now'))` };
   if (updates.title !== void 0) set.title = updates.title;
   if (updates.content !== void 0) set.content = updates.content;
-  await db.update(notes).set(set).where(eq4(notes.id, existing.id));
+  await db.update(notes).set(set).where(eq5(notes.id, existing.id));
   return getNote(authorUsername, slug).then((n) => {
     if (!n) return null;
     const { comments, replies, ...note } = n;
@@ -5014,15 +4914,15 @@ async function updateNote(authorUsername, slug, updates) {
 }
 async function deleteNote(authorUsername, slug, authorId) {
   const db = await getDb();
-  const existing = await db.select({ id: notes.id, author_id: notes.author_id }).from(notes).innerJoin(users, eq4(notes.author_id, users.id)).where(and3(eq4(users.username, authorUsername), eq4(notes.slug, slug))).get();
+  const existing = await db.select({ id: notes.id, author_id: notes.author_id }).from(notes).innerJoin(users, eq5(notes.author_id, users.id)).where(and4(eq5(users.username, authorUsername), eq5(notes.slug, slug))).get();
   if (!existing || existing.author_id !== authorId) return false;
-  await db.delete(notes).where(eq4(notes.id, existing.id));
+  await db.delete(notes).where(eq5(notes.id, existing.id));
   return true;
 }
 async function addComment(noteId, authorId, content) {
   const db = await getDb();
   const [row] = await db.insert(noteComments).values({ note_id: noteId, author_id: authorId, content }).returning();
-  const author = await db.select().from(users).where(eq4(users.id, authorId)).get();
+  const author = await db.select().from(users).where(eq5(users.id, authorId)).get();
   return {
     ...row,
     author_username: author?.username ?? "unknown",
@@ -5039,26 +4939,26 @@ async function getComments(noteId) {
     created_at: noteComments.created_at,
     author_username: users.username,
     author_display_name: users.display_name
-  }).from(noteComments).innerJoin(users, eq4(noteComments.author_id, users.id)).where(eq4(noteComments.note_id, noteId)).orderBy(noteComments.created_at).all();
+  }).from(noteComments).innerJoin(users, eq5(noteComments.author_id, users.id)).where(eq5(noteComments.note_id, noteId)).orderBy(noteComments.created_at).all();
 }
 async function deleteComment(commentId, authorId) {
   const db = await getDb();
-  const existing = await db.select({ id: noteComments.id, author_id: noteComments.author_id }).from(noteComments).where(eq4(noteComments.id, commentId)).get();
+  const existing = await db.select({ id: noteComments.id, author_id: noteComments.author_id }).from(noteComments).where(eq5(noteComments.id, commentId)).get();
   if (!existing || existing.author_id !== authorId) return false;
-  await db.delete(noteComments).where(eq4(noteComments.id, commentId));
+  await db.delete(noteComments).where(eq5(noteComments.id, commentId));
   return true;
 }
 async function toggleReaction(noteId, userId, emoji) {
   const db = await getDb();
   const existing = await db.select({ id: noteReactions.id }).from(noteReactions).where(
-    and3(
-      eq4(noteReactions.note_id, noteId),
-      eq4(noteReactions.user_id, userId),
-      eq4(noteReactions.emoji, emoji)
+    and4(
+      eq5(noteReactions.note_id, noteId),
+      eq5(noteReactions.user_id, userId),
+      eq5(noteReactions.emoji, emoji)
     )
   ).get();
   if (existing) {
-    await db.delete(noteReactions).where(eq4(noteReactions.id, existing.id));
+    await db.delete(noteReactions).where(eq5(noteReactions.id, existing.id));
     return { added: false };
   }
   await db.insert(noteReactions).values({ note_id: noteId, user_id: userId, emoji });
@@ -5069,7 +4969,7 @@ async function getReactions(noteId) {
   const rows = await db.select({
     emoji: noteReactions.emoji,
     username: users.username
-  }).from(noteReactions).innerJoin(users, eq4(noteReactions.user_id, users.id)).where(eq4(noteReactions.note_id, noteId)).orderBy(noteReactions.emoji).all();
+  }).from(noteReactions).innerJoin(users, eq5(noteReactions.user_id, users.id)).where(eq5(noteReactions.note_id, noteId)).orderBy(noteReactions.emoji).all();
   const grouped = /* @__PURE__ */ new Map();
   for (const r of rows) {
     if (!grouped.has(r.emoji)) grouped.set(r.emoji, []);
@@ -5085,7 +4985,7 @@ async function resolveNoteId(authorSlug) {
   const [author, slug] = authorSlug.split("/", 2);
   if (!author || !slug) return null;
   const db = await getDb();
-  const row = await db.select({ id: notes.id }).from(notes).innerJoin(users, eq4(notes.author_id, users.id)).where(and3(eq4(users.username, author), eq4(notes.slug, slug))).get();
+  const row = await db.select({ id: notes.id }).from(notes).innerJoin(users, eq5(notes.author_id, users.id)).where(and4(eq5(users.username, author), eq5(notes.slug, slug))).get();
   return row?.id ?? null;
 }
 
@@ -5185,7 +5085,7 @@ var notes_default = app12;
 
 // src/web/api/pages.ts
 import { readFile as readFile2, stat as stat2 } from "fs/promises";
-import { extname as extname3, resolve as resolve17 } from "path";
+import { extname as extname3, resolve as resolve16 } from "path";
 import { Hono as Hono13 } from "hono";
 var MIME_TYPES = {
   ".html": "text/html",
@@ -5207,17 +5107,17 @@ var app13 = new Hono13().get("/:name/*", async (c) => {
   const name = c.req.param("name");
   let pagesRoot;
   if (name === "_system") {
-    pagesRoot = resolve17(voluteHome(), "shared", "pages");
+    pagesRoot = resolve16(voluteHome(), "shared", "pages");
   } else {
     if (!await findMind(name)) return c.text("Not found", 404);
-    pagesRoot = resolve17(mindDir(name), "home", "public", "pages");
+    pagesRoot = resolve16(mindDir(name), "home", "public", "pages");
   }
   const wildcard = c.req.path.replace(`/pages/${name}`, "") || "/";
-  const requestedPath = resolve17(pagesRoot, wildcard.slice(1));
+  const requestedPath = resolve16(pagesRoot, wildcard.slice(1));
   if (!requestedPath.startsWith(pagesRoot)) return c.text("Forbidden", 403);
   let fileStat = await stat2(requestedPath).catch(() => null);
   if (fileStat?.isDirectory()) {
-    const indexPath = resolve17(requestedPath, "index.html");
+    const indexPath = resolve16(requestedPath, "index.html");
     fileStat = await stat2(indexPath).catch(() => null);
     if (fileStat?.isFile()) {
       const body = await readFile2(indexPath);
@@ -5237,7 +5137,7 @@ var pages_default = app13;
 
 // src/web/api/prompts.ts
 import { zValidator as zValidator6 } from "@hono/zod-validator";
-import { eq as eq5, sql as sql3 } from "drizzle-orm";
+import { eq as eq6, sql as sql3 } from "drizzle-orm";
 import { Hono as Hono14 } from "hono";
 import { z as z6 } from "zod";
 var app14 = new Hono14().get("/", async (c) => {
@@ -5281,20 +5181,20 @@ var app14 = new Hono14().get("/", async (c) => {
     return c.json({ error: "Unknown prompt key" }, 404);
   }
   const db = await getDb();
-  await db.delete(systemPrompts).where(eq5(systemPrompts.key, key));
+  await db.delete(systemPrompts).where(eq6(systemPrompts.key, key));
   return c.json({ ok: true });
 });
 var prompts_default = app14;
 
 // src/web/api/public-files.ts
 import { readdir as readdir2, readFile as readFile3, stat as stat3 } from "fs/promises";
-import { extname as extname4, resolve as resolve18 } from "path";
+import { extname as extname4, resolve as resolve17 } from "path";
 import { Hono as Hono15 } from "hono";
 var MAX_FILE_SIZE = 50 * 1024 * 1024;
 async function resolvePublicRoot(name) {
-  if (name === "_system") return resolve18(voluteHome(), "shared");
+  if (name === "_system") return resolve17(voluteHome(), "shared");
   if (!await findMind(name)) return null;
-  return resolve18(mindDir(name), "home", "public");
+  return resolve17(mindDir(name), "home", "public");
 }
 function hasDotSegment(relativePath) {
   return relativePath.split("/").some((seg) => seg.startsWith("."));
@@ -5341,7 +5241,7 @@ var app15 = new Hono15().get("/:name/", async (c) => {
   if (!publicRoot) return c.text("Not found", 404);
   const wildcard = c.req.path.replace(`/public/${name}`, "") || "/";
   const relativePath = wildcard.slice(1);
-  const requestedPath = resolve18(publicRoot, relativePath);
+  const requestedPath = resolve17(publicRoot, relativePath);
   if (!requestedPath.startsWith(publicRoot)) return c.text("Forbidden", 403);
   if (hasDotSegment(relativePath)) return c.text("Forbidden", 403);
   let fileStat;
@@ -5388,25 +5288,60 @@ function writeSchedules(name, schedules) {
   config.schedules = schedules.length > 0 ? schedules : void 0;
   writeVoluteConfig(dir, config);
   getScheduler().loadSchedules(name);
+  getSleepManagerIfReady()?.invalidateSleepConfig(name);
   fireWebhook({
     event: "schedule_changed",
     mind: name,
     data: { schedules }
   });
 }
-var app16 = new Hono16().get("/:name/schedules", async (c) => {
+var app16 = new Hono16().get("/:name/clock/status", async (c) => {
+  const name = c.req.param("name");
+  if (!await findMind(name)) return c.json({ error: "Mind not found" }, 404);
+  const sleepManager = getSleepManagerIfReady();
+  const sleepState = sleepManager?.getState(name) ?? null;
+  const sleepConfig = sleepManager?.getSleepConfig(name) ?? null;
+  const schedules = readSchedules(name);
+  const now = /* @__PURE__ */ new Date();
+  const in24h = new Date(now.getTime() + 24 * 60 * 6e4);
+  const upcoming = [];
+  for (const s of schedules) {
+    if (!s.enabled) continue;
+    if (s.fireAt) {
+      const fireDate = new Date(s.fireAt);
+      if (fireDate >= now && fireDate <= in24h) {
+        upcoming.push({ id: s.id, at: fireDate.toISOString(), type: "timer" });
+      }
+    } else if (s.cron) {
+      try {
+        const interval = CronExpressionParser.parse(s.cron);
+        const next = interval.next().toDate();
+        if (next <= in24h) {
+          upcoming.push({ id: s.id, at: next.toISOString(), type: "cron" });
+        }
+      } catch {
+        slog.warn(`invalid cron "${s.cron}" for schedule "${s.id}" of ${name}`);
+      }
+    }
+  }
+  upcoming.sort((a, b) => a.at.localeCompare(b.at));
+  return c.json({ sleep: sleepState, sleepConfig, schedules, upcoming });
+}).get("/:name/schedules", async (c) => {
   const name = c.req.param("name");
   if (!await findMind(name)) return c.json({ error: "Mind not found" }, 404);
   return c.json(readSchedules(name));
-}).post("/:name/schedules", requireAdmin, async (c) => {
+}).post("/:name/schedules", requireSelf(), async (c) => {
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   if (entry.stage === "seed")
     return c.json({ error: "Seed minds cannot use schedules \u2014 sprout first" }, 403);
   const body = await c.req.json();
-  if (!body.cron) {
-    return c.json({ error: "cron is required" }, 400);
+  if (!body.cron && !body.fireAt) {
+    return c.json({ error: "cron or fireAt is required" }, 400);
+  }
+  if (body.cron && body.fireAt) {
+    return c.json({ error: "cron and fireAt are mutually exclusive" }, 400);
   }
   if (!body.message && !body.script) {
     return c.json({ error: "message or script is required" }, 400);
@@ -5414,24 +5349,40 @@ var app16 = new Hono16().get("/:name/schedules", async (c) => {
   if (body.message && body.script) {
     return c.json({ error: "message and script are mutually exclusive" }, 400);
   }
-  try {
-    CronExpressionParser.parse(body.cron);
-  } catch {
-    return c.json({ error: `Invalid cron expression: ${body.cron}` }, 400);
+  if (body.cron) {
+    try {
+      CronExpressionParser.parse(body.cron);
+    } catch {
+      return c.json({ error: `Invalid cron expression: ${body.cron}` }, 400);
+    }
+  }
+  if (body.fireAt && Number.isNaN(new Date(body.fireAt).getTime())) {
+    return c.json({ error: `Invalid fireAt date: ${body.fireAt}` }, 400);
+  }
+  if (body.whileSleeping && !["skip", "queue", "trigger-wake"].includes(body.whileSleeping)) {
+    return c.json(
+      {
+        error: `Invalid whileSleeping value: ${body.whileSleeping} (must be skip, queue, or trigger-wake)`
+      },
+      400
+    );
   }
   const schedules = readSchedules(name);
   const id = body.id || `schedule-${Date.now()}`;
   if (schedules.some((s) => s.id === id)) {
     return c.json({ error: `Schedule "${id}" already exists` }, 409);
   }
-  const schedule = { id, cron: body.cron, enabled: body.enabled ?? true };
+  const schedule = { id, enabled: body.enabled ?? true };
+  if (body.cron) schedule.cron = body.cron;
+  if (body.fireAt) schedule.fireAt = body.fireAt;
   if (body.message) schedule.message = body.message;
   if (body.script) schedule.script = body.script;
   if (body.channel) schedule.channel = body.channel;
+  if (body.whileSleeping) schedule.whileSleeping = body.whileSleeping;
   schedules.push(schedule);
   writeSchedules(name, schedules);
   return c.json({ ok: true, id }, 201);
-}).put("/:name/schedules/:id", requireAdmin, async (c) => {
+}).put("/:name/schedules/:id", requireSelf(), async (c) => {
   const name = c.req.param("name");
   const id = c.req.param("id");
   if (!await findMind(name)) return c.json({ error: "Mind not found" }, 404);
@@ -5449,6 +5400,14 @@ var app16 = new Hono16().get("/:name/schedules", async (c) => {
       return c.json({ error: `Invalid cron expression: ${body.cron}` }, 400);
     }
     schedules[idx].cron = body.cron;
+    delete schedules[idx].fireAt;
+  }
+  if (body.fireAt !== void 0) {
+    if (Number.isNaN(new Date(body.fireAt).getTime())) {
+      return c.json({ error: `Invalid fireAt date: ${body.fireAt}` }, 400);
+    }
+    schedules[idx].fireAt = body.fireAt;
+    delete schedules[idx].cron;
   }
   if (body.message !== void 0) {
     schedules[idx].message = body.message;
@@ -5458,11 +5417,21 @@ var app16 = new Hono16().get("/:name/schedules", async (c) => {
     schedules[idx].script = body.script;
     delete schedules[idx].message;
   }
+  if (body.whileSleeping && !["skip", "queue", "trigger-wake"].includes(body.whileSleeping)) {
+    return c.json(
+      {
+        error: `Invalid whileSleeping value: ${body.whileSleeping} (must be skip, queue, or trigger-wake)`
+      },
+      400
+    );
+  }
   if (body.enabled !== void 0) schedules[idx].enabled = body.enabled;
   if (body.channel !== void 0) schedules[idx].channel = body.channel || void 0;
+  if (body.whileSleeping !== void 0)
+    schedules[idx].whileSleeping = body.whileSleeping || void 0;
   writeSchedules(name, schedules);
   return c.json({ ok: true });
-}).delete("/:name/schedules/:id", requireAdmin, async (c) => {
+}).delete("/:name/schedules/:id", requireSelf(), async (c) => {
   const name = c.req.param("name");
   const id = c.req.param("id");
   if (!await findMind(name)) return c.json({ error: "Mind not found" }, 404);
@@ -5520,44 +5489,13 @@ var app17 = new Hono17().post("/:name/shared/merge", requireAdmin, async (c) =>
   } catch (err) {
     return c.json({ error: err instanceof Error ? err.message : "Merge failed" }, 500);
   }
-}).post("/:name/shared/pull", requireAdmin, async (c) => {
-  const name = c.req.param("name");
-  const entry = await findMind(name);
-  if (!entry) return c.json({ error: "Mind not found" }, 404);
-  try {
-    const result = await sharedPull(name, mindDir(name));
-    return c.json(result);
-  } catch (err) {
-    return c.json({ error: err instanceof Error ? err.message : "Pull failed" }, 500);
-  }
-}).get("/:name/shared/log", async (c) => {
-  const name = c.req.param("name");
-  const entry = await findMind(name);
-  if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const limit = parseInt(c.req.query("limit") ?? "20", 10) || 20;
-  try {
-    const log2 = await sharedLog(limit);
-    return c.text(log2);
-  } catch (err) {
-    return c.json({ error: err instanceof Error ? err.message : "Failed to read log" }, 500);
-  }
-}).get("/:name/shared/status", async (c) => {
-  const name = c.req.param("name");
-  const entry = await findMind(name);
-  if (!entry) return c.json({ error: "Mind not found" }, 404);
-  try {
-    const status = await sharedStatus(name);
-    return c.text(status);
-  } catch (err) {
-    return c.json({ error: err instanceof Error ? err.message : "Failed to get status" }, 500);
-  }
 });
 var shared_default = app17;
 
 // src/web/api/skills.ts
-import { existsSync as existsSync15, mkdtempSync, readdirSync as readdirSync5, rmSync as rmSync6 } from "fs";
+import { existsSync as existsSync14, mkdtempSync, readdirSync as readdirSync4, rmSync as rmSync5 } from "fs";
 import { tmpdir } from "os";
-import { join as join2, resolve as resolve19 } from "path";
+import { join, resolve as resolve18 } from "path";
 import AdmZip from "adm-zip";
 import { Hono as Hono18 } from "hono";
 var app18 = new Hono18().get("/", async (c) => {
@@ -5567,7 +5505,7 @@ var app18 = new Hono18().get("/", async (c) => {
   const id = c.req.param("id");
   const skill = await getSharedSkill(id);
   if (!skill) return c.json({ error: "Skill not found" }, 404);
-  const dir = join2(sharedSkillsDir(), id);
+  const dir = join(sharedSkillsDir(), id);
   const files = listFilesRecursive(dir);
   return c.json({ ...skill, files });
 }).post("/upload", requireAdmin, async (c) => {
@@ -5580,24 +5518,24 @@ var app18 = new Hono18().get("/", async (c) => {
     return c.json({ error: "Only .zip files are accepted" }, 400);
   }
   const buffer2 = Buffer.from(await file.arrayBuffer());
-  const tmpDir = mkdtempSync(join2(tmpdir(), "volute-skill-upload-"));
+  const tmpDir = mkdtempSync(join(tmpdir(), "volute-skill-upload-"));
   try {
     const zip = new AdmZip(buffer2);
     for (const entry of zip.getEntries()) {
-      const target = resolve19(tmpDir, entry.entryName);
+      const target = resolve18(tmpDir, entry.entryName);
       if (!target.startsWith(tmpDir)) {
         return c.json({ error: "Invalid zip: paths must not escape archive" }, 400);
       }
     }
     zip.extractAllTo(tmpDir, true);
     let skillDir = null;
-    if (existsSync15(join2(tmpDir, "SKILL.md"))) {
+    if (existsSync14(join(tmpDir, "SKILL.md"))) {
       skillDir = tmpDir;
     } else {
-      const entries = readdirSync5(tmpDir, { withFileTypes: true }).filter((e) => e.isDirectory());
+      const entries = readdirSync4(tmpDir, { withFileTypes: true }).filter((e) => e.isDirectory());
       for (const entry of entries) {
-        if (existsSync15(join2(tmpDir, entry.name, "SKILL.md"))) {
-          skillDir = join2(tmpDir, entry.name);
+        if (existsSync14(join(tmpDir, entry.name, "SKILL.md"))) {
+          skillDir = join(tmpDir, entry.name);
           break;
         }
       }
@@ -5613,7 +5551,7 @@ var app18 = new Hono18().get("/", async (c) => {
     }
     throw e;
   } finally {
-    rmSync6(tmpDir, { recursive: true, force: true });
+    rmSync5(tmpDir, { recursive: true, force: true });
   }
 }).delete("/:id", requireAdmin, async (c) => {
   const id = c.req.param("id");
@@ -5650,10 +5588,10 @@ var app19 = new Hono19().post("/restart", requireAdmin, (c) => {
       stream.writeSSE({ data: JSON.stringify(entry) }).catch(() => {
       });
     });
-    await new Promise((resolve24) => {
+    await new Promise((resolve23) => {
       stream.onAbort(() => {
         unsubscribe();
-        resolve24();
+        resolve23();
       });
     });
   });
@@ -5738,6 +5676,38 @@ var app19 = new Hono19().post("/restart", requireAdmin, (c) => {
 ).post("/logout", requireAdmin, (c) => {
   deleteSystemsConfig();
   return c.json({ ok: true });
+}).put("/pages/publish/:name", requireAdmin, async (c) => {
+  const config = readSystemsConfig();
+  if (!config) return c.json({ error: "Not connected to volute.systems" }, 400);
+  const name = c.req.param("name");
+  const body = await c.req.text();
+  try {
+    const res = await fetch(`${config.apiUrl}/api/pages/publish/${name}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.apiKey}`
+      },
+      body
+    });
+    const data = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
+    return c.json(data, res.status);
+  } catch (err) {
+    return c.json({ error: `Connection failed: ${err.message}` }, 502);
+  }
+}).get("/pages/status/:name", requireAdmin, async (c) => {
+  const config = readSystemsConfig();
+  if (!config) return c.json({ error: "Not connected to volute.systems" }, 400);
+  const name = c.req.param("name");
+  try {
+    const res = await fetch(`${config.apiUrl}/api/pages/status/${name}`, {
+      headers: { Authorization: `Bearer ${config.apiKey}` }
+    });
+    const data = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
+    return c.json(data, res.status);
+  } catch (err) {
+    return c.json({ error: `Connection failed: ${err.message}` }, 502);
+  }
 });
 var system_default = app19;
 
@@ -5805,11 +5775,11 @@ async function fanOutToMinds(opts) {
   const mindParticipants = participants.filter((p) => p.userType === "mind");
   const participantNames = participants.map((p) => p.username);
   const isDM = opts.isDM ?? participants.length === 2;
-  const channelEntryType = opts.channelEntryType ?? (isDM ? "dm" : "group");
-  const { getMindManager: getMindManager2 } = await import("./mind-manager-M6EMUW5I.js");
-  const { getSleepManagerIfReady } = await import("./sleep-manager-MWYHM5HV.js");
+  const channelEntryType = opts.channelEntryType ?? (isDM ? "dm" : "channel");
+  const { getMindManager: getMindManager2 } = await import("./mind-manager-P66HQDNE.js");
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G4B5GW5P.js");
   const manager = getMindManager2();
-  const sm = getSleepManagerIfReady();
+  const sm = getSleepManagerIfReady2();
   const targetMinds = mindParticipants.map((ap) => {
     const key = opts.targetName ? opts.targetName(ap.username) : ap.username;
     if (manager.isRunning(key) || sm?.isSleeping(ap.username)) return ap.username;
@@ -5928,7 +5898,7 @@ var app22 = new Hono22().use("*", authMiddleware).post("/minds/:name/chat", zVal
     senderName,
     convTitle,
     isDM,
-    channelEntryType: conv?.type === "channel" ? "group" : isDM ? "dm" : "group",
+    channelEntryType: isDM ? "dm" : "channel",
     slugExtra: conv ? { convType: conv.type, convName: conv.name } : void 0,
     targetName: (username) => username === baseName ? name : username
   });
@@ -5950,11 +5920,11 @@ var app22 = new Hono22().use("*", authMiddleware).post("/minds/:name/chat", zVal
         if (!stream.aborted) logger_default.error("[v1-chat] SSE ping error:", logger_default.errorData(err));
       });
     }, 15e3);
-    await new Promise((resolve24) => {
+    await new Promise((resolve23) => {
       stream.onAbort(() => {
         unsubscribe();
         clearInterval(keepAlive);
-        resolve24();
+        resolve23();
       });
     });
   });
@@ -5985,7 +5955,7 @@ var app22 = new Hono22().use("*", authMiddleware).post("/minds/:name/chat", zVal
     senderName,
     convTitle: conv.title,
     isDM,
-    channelEntryType: conv.type === "channel" ? "group" : isDM ? "dm" : "group",
+    channelEntryType: isDM ? "dm" : "channel",
     slugExtra: { convType: conv.type, convName: conv.name }
   });
   return c.json({ ok: true, conversationId: body.conversationId });
@@ -6222,8 +6192,8 @@ var app24 = new Hono24().use("*", authMiddleware).get("/", async (c) => {
         });
       }, 15e3);
       cleanups.push(() => clearInterval(keepAlive));
-      await new Promise((resolve24) => {
-        stream.onAbort(() => resolve24());
+      await new Promise((resolve23) => {
+        stream.onAbort(() => resolve23());
       });
     } finally {
       for (const cleanup of cleanups) {
@@ -6238,16 +6208,16 @@ var app24 = new Hono24().use("*", authMiddleware).get("/", async (c) => {
 var events_default = app24;
 
 // src/web/api/variants.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync11, writeFileSync as writeFileSync10 } from "fs";
-import { resolve as resolve21 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync10, writeFileSync as writeFileSync9 } from "fs";
+import { resolve as resolve20 } from "path";
 import { Hono as Hono25 } from "hono";
 
 // src/lib/spawn-server.ts
 import { spawn as spawn4 } from "child_process";
-import { closeSync, mkdirSync as mkdirSync10, openSync, readFileSync as readFileSync13 } from "fs";
-import { resolve as resolve20 } from "path";
+import { closeSync, mkdirSync as mkdirSync9, openSync, readFileSync as readFileSync12 } from "fs";
+import { resolve as resolve19 } from "path";
 function tsxBin(cwd) {
-  return resolve20(cwd, "node_modules", ".bin", "tsx");
+  return resolve19(cwd, "node_modules", ".bin", "tsx");
 }
 function spawnServer(cwd, port, options) {
   if (options?.detached) {
@@ -6260,31 +6230,31 @@ function spawnAttached(cwd, port) {
     cwd,
     stdio: ["ignore", "pipe", "pipe"]
   });
-  return new Promise((resolve24) => {
-    const timeout = setTimeout(() => resolve24(null), 3e4);
+  return new Promise((resolve23) => {
+    const timeout = setTimeout(() => resolve23(null), 3e4);
     function checkOutput(data) {
       const match = data.toString().match(/listening on :(\d+)/);
       if (match) {
         clearTimeout(timeout);
-        resolve24({ child, actualPort: parseInt(match[1], 10) });
+        resolve23({ child, actualPort: parseInt(match[1], 10) });
       }
     }
     child.stdout?.on("data", checkOutput);
     child.stderr?.on("data", checkOutput);
     child.on("error", () => {
       clearTimeout(timeout);
-      resolve24(null);
+      resolve23(null);
     });
     child.on("exit", () => {
       clearTimeout(timeout);
-      resolve24(null);
+      resolve23(null);
     });
   });
 }
 function spawnDetached(cwd, port, logDir) {
-  const logsDir = logDir ?? resolve20(cwd, ".mind", "logs");
-  mkdirSync10(logsDir, { recursive: true });
-  const logPath = resolve20(logsDir, "mind.log");
+  const logsDir = logDir ?? resolve19(cwd, ".mind", "logs");
+  mkdirSync9(logsDir, { recursive: true });
+  const logPath = resolve19(logsDir, "mind.log");
   const logFd = openSync(logPath, "a");
   const child = spawn4(tsxBin(cwd), ["src/server.ts", "--port", String(port)], {
     cwd,
@@ -6304,7 +6274,7 @@ function spawnDetached(cwd, port, logDir) {
     }
     const interval = setInterval(() => {
       try {
-        const content = readFileSync13(logPath, "utf-8");
+        const content = readFileSync12(logPath, "utf-8");
         const match = content.match(/listening on :(\d+)/);
         if (match) {
           finish({ child, actualPort: parseInt(match[1], 10) });
@@ -6380,7 +6350,7 @@ var app25 = new Hono25().get("/:name/variants", async (c) => {
     logger_default.warn(`failed to sync variant status for ${name}`, logger_default.errorData(err));
   }
   return c.json(results);
-}).post("/:name/variants", requireAdmin, async (c) => {
+}).post("/:name/variants", requireSelf(), async (c) => {
   const mindName = c.req.param("name");
   const entry = await findMind(mindName);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
@@ -6400,11 +6370,11 @@ var app25 = new Hono25().get("/:name/variants", async (c) => {
     return c.json({ error: `Name already in use: ${variantName}` }, 409);
   }
   const projectRoot = mindDir(mindName);
-  const variantDir = resolve21(projectRoot, ".variants", variantName);
-  if (existsSync16(variantDir)) {
+  const variantDir = resolve20(projectRoot, ".variants", variantName);
+  if (existsSync15(variantDir)) {
     return c.json({ error: `Variant directory already exists: ${variantDir}` }, 409);
   }
-  mkdirSync11(resolve21(projectRoot, ".variants"), { recursive: true });
+  mkdirSync10(resolve20(projectRoot, ".variants"), { recursive: true });
   try {
     await gitExec(["worktree", "add", "-b", variantName, variantDir], { cwd: projectRoot });
   } catch (e) {
@@ -6417,7 +6387,7 @@ var app25 = new Hono25().get("/:name/variants", async (c) => {
       const [cmd, args] = await wrapForIsolation("npm", ["install"], mindName);
       await exec(cmd, args, {
         cwd: variantDir,
-        env: { ...process.env, HOME: resolve21(variantDir, "home") }
+        env: { ...process.env, HOME: resolve20(variantDir, "home") }
       });
     } else {
       await exec("npm", ["install"], { cwd: variantDir });
@@ -6427,7 +6397,7 @@ var app25 = new Hono25().get("/:name/variants", async (c) => {
     return c.json({ error: `npm install failed: ${msg}` }, 500);
   }
   if (body.soul) {
-    writeFileSync10(resolve21(variantDir, "home/SOUL.md"), body.soul);
+    writeFileSync9(resolve20(variantDir, "home/SOUL.md"), body.soul);
   }
   const variantPort = body.port ?? await nextPort();
   await addVariant(variantName, mindName, variantPort, variantDir, variantName);
@@ -6443,7 +6413,7 @@ var app25 = new Hono25().get("/:name/variants", async (c) => {
     ok: true,
     variant: { name: variantName, branch: variantName, path: variantDir, port: variantPort }
   });
-}).post("/:name/variants/:variant/merge", requireAdmin, async (c) => {
+}).post("/:name/variants/:variant/merge", requireSelf(), async (c) => {
   const mindName = c.req.param("name");
   const variantName = c.req.param("variant");
   const parentEntry = await findMind(mindName);
@@ -6462,7 +6432,7 @@ var app25 = new Hono25().get("/:name/variants", async (c) => {
   } catch {
   }
   const projectRoot = mindDir(mindName);
-  if (existsSync16(variantEntry.dir)) {
+  if (existsSync15(variantEntry.dir)) {
     const status = (await gitExec(["status", "--porcelain"], { cwd: variantEntry.dir })).trim();
     if (status) {
       try {
@@ -6536,7 +6506,7 @@ var app25 = new Hono25().get("/:name/variants", async (c) => {
       const [cmd, args] = await wrapForIsolation("npm", ["install"], mindName);
       await exec(cmd, args, {
         cwd: projectRoot,
-        env: { ...process.env, HOME: resolve21(projectRoot, "home") }
+        env: { ...process.env, HOME: resolve20(projectRoot, "home") }
       });
     } else {
       await exec("npm", ["install"], { cwd: projectRoot });
@@ -6564,7 +6534,7 @@ var app25 = new Hono25().get("/:name/variants", async (c) => {
     logger_default.warn(restartWarning);
   }
   return c.json({ ok: true, ...restartWarning && { warning: restartWarning } });
-}).delete("/:name/variants/:variant", requireAdmin, async (c) => {
+}).delete("/:name/variants/:variant", requireSelf(), async (c) => {
   const mindName = c.req.param("name");
   const variantName = c.req.param("variant");
   const parentEntry = await findMind(mindName);
@@ -6739,11 +6709,11 @@ async function fanOutToMinds2(opts) {
   const mindParticipants = participants.filter((p) => p.userType === "mind");
   const participantNames = participants.map((p) => p.username);
   const isDM = opts.isDM ?? participants.length === 2;
-  const channelEntryType = opts.channelEntryType ?? (isDM ? "dm" : "group");
-  const { getMindManager: getMindManager2 } = await import("./mind-manager-M6EMUW5I.js");
-  const { getSleepManagerIfReady } = await import("./sleep-manager-MWYHM5HV.js");
+  const channelEntryType = opts.channelEntryType ?? (isDM ? "dm" : "channel");
+  const { getMindManager: getMindManager2 } = await import("./mind-manager-P66HQDNE.js");
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G4B5GW5P.js");
   const manager = getMindManager2();
-  const sm = getSleepManagerIfReady();
+  const sm = getSleepManagerIfReady2();
   const targetMinds = mindParticipants.map((ap) => {
     const key = opts.targetName ? opts.targetName(ap.username) : ap.username;
     if (manager.isRunning(key) || sm?.isSleeping(ap.username)) return ap.username;
@@ -6790,6 +6760,11 @@ async function fanOutToMinds2(opts) {
     });
   }
 }
+var fileSchema = z12.object({
+  filename: z12.string(),
+  data: z12.string()
+  // base64
+});
 var chatSchema = z12.object({
   message: z12.string().optional(),
   conversationId: z12.string().optional(),
@@ -6799,7 +6774,8 @@ var chatSchema = z12.object({
       media_type: z12.string(),
       data: z12.string()
     })
-  ).optional()
+  ).optional(),
+  files: z12.array(fileSchema).optional()
 });
 var app27 = new Hono27().post("/:name/chat", zValidator12("json", chatSchema), async (c) => {
   const name = c.req.param("name");
@@ -6807,8 +6783,8 @@ var app27 = new Hono27().post("/:name/chat", zValidator12("json", chatSchema), a
   const entry = await findMind(baseName);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const body = c.req.valid("json");
-  if (!body.message && (!body.images || body.images.length === 0)) {
-    return c.json({ error: "message or images required" }, 400);
+  if (!body.message && (!body.images || body.images.length === 0) && (!body.files || body.files.length === 0)) {
+    return c.json({ error: "message, images, or files required" }, 400);
   }
   const user = c.get("user");
   const mindUser = await getOrCreateMindUser(baseName);
@@ -6849,10 +6825,34 @@ var app27 = new Hono27().post("/:name/chat", zValidator12("json", chatSchema), a
   }
   const conv = await getConversation(conversationId);
   const convTitle = conv?.title ?? null;
+  const fileNotifications = [];
+  if (body.files && body.files.length > 0) {
+    const MAX_FILE_SIZE2 = 50 * 1024 * 1024;
+    for (const file of body.files) {
+      const pathErr = validateFilePath(file.filename);
+      if (pathErr) return c.json({ error: `Invalid filename: ${pathErr}` }, 400);
+      const content = Buffer.from(file.data, "base64");
+      if (content.length > MAX_FILE_SIZE2) {
+        return c.json(
+          {
+            error: `File too large: ${file.filename} (${formatFileSize(content.length)}, max ${formatFileSize(MAX_FILE_SIZE2)})`
+          },
+          413
+        );
+      }
+      const { id } = stageFile(baseName, senderName, file.filename, content, file.filename);
+      fileNotifications.push(
+        `[file] ${senderName} sent ${file.filename} (${formatFileSize(content.length)}) \u2014 run: volute chat accept ${id}`
+      );
+    }
+  }
   const contentBlocks = [];
   if (body.message) {
     contentBlocks.push({ type: "text", text: body.message });
   }
+  for (const note of fileNotifications) {
+    contentBlocks.push({ type: "text", text: note });
+  }
   if (body.images) {
     for (const img of body.images) {
       contentBlocks.push({ type: "image", media_type: img.media_type, data: img.data });
@@ -6872,7 +6872,7 @@ var app27 = new Hono27().post("/:name/chat", zValidator12("json", chatSchema), a
     senderName,
     convTitle,
     isDM,
-    channelEntryType: conv?.type === "channel" ? "group" : isDM ? "dm" : "group",
+    channelEntryType: isDM ? "dm" : "channel",
     slugExtra: conv ? { convType: conv.type, convName: conv.name } : void 0,
     targetName: (username) => username === baseName ? name : username
   });
@@ -6894,11 +6894,11 @@ var app27 = new Hono27().post("/:name/chat", zValidator12("json", chatSchema), a
         if (!stream.aborted) console.error("[chat] SSE ping error:", err);
       });
     }, 15e3);
-    await new Promise((resolve24) => {
+    await new Promise((resolve23) => {
       stream.onAbort(() => {
         unsubscribe();
         clearInterval(keepAlive);
-        resolve24();
+        resolve23();
       });
     });
   });
@@ -6906,7 +6906,8 @@ var app27 = new Hono27().post("/:name/chat", zValidator12("json", chatSchema), a
 var unifiedChatSchema2 = z12.object({
   message: z12.string().optional(),
   conversationId: z12.string(),
-  images: z12.array(z12.object({ media_type: z12.string(), data: z12.string() })).optional()
+  images: z12.array(z12.object({ media_type: z12.string(), data: z12.string() })).optional(),
+  files: z12.array(fileSchema).optional()
 });
 var unifiedChatApp = new Hono27().post(
   "/chat",
@@ -6914,8 +6915,8 @@ var unifiedChatApp = new Hono27().post(
   async (c) => {
     const user = c.get("user");
     const body = c.req.valid("json");
-    if (!body.message && (!body.images || body.images.length === 0)) {
-      return c.json({ error: "message or images required" }, 400);
+    if (!body.message && (!body.images || body.images.length === 0) && (!body.files || body.files.length === 0)) {
+      return c.json({ error: "message, images, or files required" }, 400);
     }
     const conv = await getConversation(body.conversationId);
     if (!conv) return c.json({ error: "Conversation not found" }, 404);
@@ -6923,8 +6924,44 @@ var unifiedChatApp = new Hono27().post(
       return c.json({ error: "Conversation not found" }, 404);
     }
     const senderName = user.username;
+    const fileNotifications = [];
+    if (body.files && body.files.length > 0) {
+      const participants = await getParticipants(body.conversationId);
+      const mindParticipants = participants.filter(
+        (p) => p.userType === "mind" && p.username !== senderName
+      );
+      const MAX_FILE_SIZE2 = 50 * 1024 * 1024;
+      for (const file of body.files) {
+        const pathErr = validateFilePath(file.filename);
+        if (pathErr) return c.json({ error: `Invalid filename: ${pathErr}` }, 400);
+        const content = Buffer.from(file.data, "base64");
+        if (content.length > MAX_FILE_SIZE2) {
+          return c.json(
+            {
+              error: `File too large: ${file.filename} (${formatFileSize(content.length)}, max ${formatFileSize(MAX_FILE_SIZE2)})`
+            },
+            413
+          );
+        }
+        for (const mind of mindParticipants) {
+          const { id } = stageFile(
+            mind.username,
+            senderName,
+            file.filename,
+            content,
+            file.filename
+          );
+          fileNotifications.push(
+            `[file] ${senderName} sent ${file.filename} (${formatFileSize(content.length)}) \u2014 run: volute chat accept ${id}`
+          );
+        }
+      }
+    }
     const contentBlocks = [];
     if (body.message) contentBlocks.push({ type: "text", text: body.message });
+    for (const note of fileNotifications) {
+      contentBlocks.push({ type: "text", text: note });
+    }
     if (body.images) {
       for (const img of body.images) {
         contentBlocks.push({ type: "image", media_type: img.media_type, data: img.data });
@@ -6943,7 +6980,7 @@ var unifiedChatApp = new Hono27().post(
       senderName,
       convTitle: conv.title,
       isDM,
-      channelEntryType: conv.type === "channel" ? "group" : isDM ? "dm" : "group",
+      channelEntryType: isDM ? "dm" : "channel",
       slugExtra: { convType: conv.type, convName: conv.name }
     });
     return c.json({ ok: true, conversationId: body.conversationId });
@@ -7013,6 +7050,9 @@ var app28 = new Hono28().get("/:name/conversations", async (c) => {
     if (!u) return c.json({ error: `User ${id} not found` }, 400);
   }
   const participantIds = [...participantSet];
+  if (participantIds.length > 2) {
+    return c.json({ error: "Use channels for multi-participant conversations" }, 400);
+  }
   if (participantIds.length === 2) {
     const existingId = await findDMConversation(name, participantIds);
     if (existingId) {
@@ -7101,6 +7141,9 @@ var app29 = new Hono29().use("*", authMiddleware).get("/", async (c) => {
   if (!firstMindName) {
     return c.json({ error: "At least one mind participant is required" }, 400);
   }
+  if (participantIds.size > 2) {
+    return c.json({ error: "Use channels for multi-participant conversations" }, 400);
+  }
   const conv = await createConversation(firstMindName, "volute", {
     userId: user.id !== 0 ? user.id : void 0,
     title: body.title,
@@ -7124,11 +7167,11 @@ var app29 = new Hono29().use("*", authMiddleware).get("/", async (c) => {
         if (!stream.aborted) console.error("[chat] SSE ping error:", err);
       });
     }, 15e3);
-    await new Promise((resolve24) => {
+    await new Promise((resolve23) => {
       stream.onAbort(() => {
         unsubscribe();
         clearInterval(keepAlive);
-        resolve24();
+        resolve23();
       });
     });
   });
@@ -7234,8 +7277,8 @@ async function startServer({
   let assetsDir = "";
   let searchDir = dirname2(new URL(import.meta.url).pathname);
   for (let i = 0; i < 5; i++) {
-    const candidate = resolve22(searchDir, "dist", "web-assets");
-    if (existsSync17(candidate)) {
+    const candidate = resolve21(searchDir, "dist", "web-assets");
+    if (existsSync16(candidate)) {
       assetsDir = candidate;
       break;
     }
@@ -7245,7 +7288,7 @@ async function startServer({
     app_default.get("*", async (c) => {
       const urlPath = new URL(c.req.url).pathname;
       if (urlPath.startsWith("/api/")) return c.notFound();
-      const filePath = resolve22(assetsDir, urlPath.slice(1));
+      const filePath = resolve21(assetsDir, urlPath.slice(1));
       if (!filePath.startsWith(assetsDir)) return c.text("Forbidden", 403);
       const s = await stat4(filePath).catch(() => null);
       if (s?.isFile()) {
@@ -7254,7 +7297,7 @@ async function startServer({
         const body = await readFile4(filePath);
         return c.body(body, 200, { "Content-Type": mime });
       }
-      const indexPath = resolve22(assetsDir, "index.html");
+      const indexPath = resolve21(assetsDir, "index.html");
       const indexStat = await stat4(indexPath).catch(() => null);
       if (indexStat?.isFile()) {
         const body = await readFile4(indexPath, "utf-8");
@@ -7271,10 +7314,10 @@ async function startServer({
       createServer: createHttpsServer,
       serverOptions: { key: tls.key, cert: tls.cert }
     });
-    await new Promise((resolve24, reject) => {
+    await new Promise((resolve23, reject) => {
       server2.on("listening", () => {
         logger_default.info("Volute UI running (https)", { hostname, port });
-        resolve24();
+        resolve23();
       });
       server2.on("error", (err) => {
         reject(err);
@@ -7282,13 +7325,13 @@ async function startServer({
     });
     const internalPort = port + 1;
     const internalServer = serve({ fetch: app_default.fetch, port: internalPort, hostname: "127.0.0.1" });
-    await new Promise((resolve24, reject) => {
+    await new Promise((resolve23, reject) => {
       internalServer.on("listening", () => {
         logger_default.info("Volute API running (http, internal)", {
           hostname: "127.0.0.1",
           port: internalPort
         });
-        resolve24();
+        resolve23();
       });
       internalServer.on("error", (err) => {
         reject(err);
@@ -7297,10 +7340,10 @@ async function startServer({
     return { server: server2, internalPort };
   }
   const server = serve({ fetch: app_default.fetch, port, hostname });
-  await new Promise((resolve24, reject) => {
+  await new Promise((resolve23, reject) => {
     server.on("listening", () => {
       logger_default.info("Volute API running (http)", { hostname, port });
-      resolve24();
+      resolve23();
     });
     server.on("error", (err) => {
       reject(err);
@@ -7311,7 +7354,7 @@ async function startServer({
 
 // src/daemon.ts
 if (!process.env.VOLUTE_HOME) {
-  process.env.VOLUTE_HOME = resolve23(homedir2(), ".volute");
+  process.env.VOLUTE_HOME = resolve22(homedir2(), ".volute");
 }
 if (process.env.VOLUTE_TIMEZONE && !process.env.TZ) {
   process.env.TZ = process.env.VOLUTE_TIMEZONE;
@@ -7322,7 +7365,7 @@ async function startDaemon(opts) {
   const home = voluteHome();
   const systemDir = voluteSystemDir();
   if (!opts.foreground) {
-    const rotatingLog = new RotatingLog(resolve23(systemDir, "daemon.log"));
+    const rotatingLog = new RotatingLog(resolve22(systemDir, "daemon.log"));
     logger_default.setOutput((line) => rotatingLog.write(`${line}
 `));
     const write = (...args) => rotatingLog.write(`${format(...args)}
@@ -7332,9 +7375,9 @@ async function startDaemon(opts) {
     console.warn = write;
     console.info = write;
   }
-  const DAEMON_PID_PATH = resolve23(systemDir, "daemon.pid");
-  const DAEMON_JSON_PATH = resolve23(systemDir, "daemon.json");
-  mkdirSync12(home, { recursive: true });
+  const DAEMON_PID_PATH = resolve22(systemDir, "daemon.pid");
+  const DAEMON_JSON_PATH = resolve22(systemDir, "daemon.json");
+  mkdirSync11(home, { recursive: true });
   ensureSystemDir();
   migrateToSystemDir();
   migrateAgentsToMinds();
@@ -7346,7 +7389,13 @@ async function startDaemon(opts) {
   await (await import("./db-IC4J52XQ.js")).getDb();
   const { migrateRegistryToDb } = await import("./migrate-registry-to-db-XC7T5B7P.js");
   migrateRegistryToDb();
-  const { initSandbox } = await import("./sandbox-TGBX22DS.js");
+  try {
+    const { migrateGroupDMsToChannels } = await import("./conversations-P5BL7RMX.js");
+    await migrateGroupDMsToChannels();
+  } catch (err) {
+    logger_default.error("failed to migrate group DMs to channels", logger_default.errorData(err));
+  }
+  const { initSandbox } = await import("./sandbox-5BW5HPXM.js");
   await initSandbox();
   try {
     await syncBuiltinSkills();
@@ -7358,7 +7407,9 @@ async function startDaemon(opts) {
   } catch (err) {
     logger_default.warn("failed to ensure #system channel", logger_default.errorData(err));
   }
-  const token = process.env.VOLUTE_DAEMON_TOKEN || randomBytes2(32).toString("hex");
+  const { startSystemWatcher } = await import("./pages-watcher-P7QECRE2.js");
+  startSystemWatcher();
+  const token = process.env.VOLUTE_DAEMON_TOKEN || randomBytes(32).toString("hex");
   let tls;
   if (opts.tailscale) {
     const { getTailscaleTls } = await import("./tailscale-NY5MUMY3.js");
@@ -7382,11 +7433,11 @@ async function startDaemon(opts) {
   process.env.VOLUTE_DAEMON_TOKEN = token;
   process.env.VOLUTE_DAEMON_PORT = String(daemonPort);
   process.env.VOLUTE_DAEMON_HOSTNAME = hostname;
-  writeFileSync11(DAEMON_PID_PATH, myPid, { mode: 420 });
+  writeFileSync10(DAEMON_PID_PATH, myPid, { mode: 420 });
   const daemonConfig = { port, hostname, token };
   if (internalPort) daemonConfig.internalPort = internalPort;
   if (tls) daemonConfig.tls = true;
-  writeFileSync11(DAEMON_JSON_PATH, `${JSON.stringify(daemonConfig, null, 2)}
+  writeFileSync10(DAEMON_JSON_PATH, `${JSON.stringify(daemonConfig, null, 2)}
 `, { mode: 420 });
   const delivery = initDeliveryManager();
   const manager = initMindManager();
@@ -7442,7 +7493,7 @@ async function startDaemon(opts) {
   bridgeManager.startBridges(daemonPort).catch((err) => {
     logger_default.warn("failed to start bridges", logger_default.errorData(err));
   });
-  import("./cloud-sync-T7M3ESC3.js").then(
+  import("./cloud-sync-KILFGV5Q.js").then(
     ({ consumeQueuedMessages }) => consumeQueuedMessages().catch((err) => {
       logger_default.warn("failed to consume queued cloud messages", logger_default.errorData(err));
     })
@@ -7450,7 +7501,7 @@ async function startDaemon(opts) {
     logger_default.warn("failed to load cloud-sync module", logger_default.errorData(err));
   });
   try {
-    const { backfillTemplateHashes, notifyVersionUpdate } = await import("./version-notify-5Z4MNR6M.js");
+    const { backfillTemplateHashes, notifyVersionUpdate } = await import("./version-notify-WDHRO3XD.js");
     backfillTemplateHashes();
     notifyVersionUpdate().catch((err) => {
       logger_default.warn("failed to send version update notifications", logger_default.errorData(err));
@@ -7464,19 +7515,22 @@ async function startDaemon(opts) {
   cleanExpiredSessions().catch((err) => {
     logger_default.warn("failed to clean expired sessions", logger_default.errorData(err));
   });
+  cleanExpiredLogs().catch((err) => {
+    logger_default.warn("failed to clean expired logs", logger_default.errorData(err));
+  });
   migrateMindRoles().catch((err) => {
     logger_default.warn("failed to migrate mind roles", logger_default.errorData(err));
   });
   logger_default.info(`running on ${hostname}:${port}, pid ${myPid}`);
   function cleanup() {
     try {
-      if (readFileSync14(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
+      if (readFileSync13(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
         unlinkSync2(DAEMON_PID_PATH);
       }
     } catch {
     }
     try {
-      const data = JSON.parse(readFileSync14(DAEMON_JSON_PATH, "utf-8"));
+      const data = JSON.parse(readFileSync13(DAEMON_JSON_PATH, "utf-8"));
       if (data.token === token) {
         unlinkSync2(DAEMON_JSON_PATH);
       }