volute 0.29.0 → 0.30.1

package/dist/daemon.js

@@ -1,62 +1,51 @@
 #!/usr/bin/env node
-import {
-  addSharedWorktree,
-  ensureSharedRepo,
-  removeSharedWorktree,
-  sharedMerge
-} from "./chunk-P72MVS4R.js";
 import {
   announceToSystem,
-  approveUser,
-  changePassword,
-  countAdmins,
-  createUser,
-  deleteMindUser as deleteMindUser2,
-  deleteSystemsConfig,
-  deleteUser,
   deliverMessage,
   ensureSystemChannel,
   extractTextContent,
   getDeliveryManager,
-  getOrCreateMindUser,
   getScheduler,
   getSleepManagerIfReady,
   getTokenBudget,
   getTypingMap,
-  getUser,
-  getUserByUsername,
   initDeliveryManager,
   initMailPoller,
   initScheduler,
   initSleepManager,
   initTokenBudget,
   joinSystemChannel,
-  listPendingUsers,
-  listUsers,
-  listUsersByType,
-  migrateMindRoles,
   publish as publish2,
   publishTypingForChannels,
-  readSystemsConfig,
   readVoluteConfig,
   recordInbound,
   resolveChannelId,
-  setUserRole,
   splitMessage,
   startMindFull,
   stopMindFull,
   subscribe as subscribe3,
-  updateUserProfile,
-  verifyUser,
   writeChannelEntry,
-  writeSystemsConfig,
   writeVoluteConfig
-} from "./chunk-CMILSHZD.js";
+} from "./chunk-QVAQ5454.js";
 import {
-  getCachedRecentPages,
-  getCachedSites,
-  stopAllWatchers
-} from "./chunk-THUUIU3E.js";
+  getActiveMinds,
+  onMindEvent,
+  stopAll
+} from "./chunk-FSM45XD5.js";
+import {
+  PROMPT_DEFAULTS,
+  PROMPT_KEYS,
+  RestartTracker,
+  RotatingLog,
+  getMindManager,
+  getMindPromptDefaults,
+  getPrompt,
+  getPromptIfCustom,
+  initMindManager,
+  resolveMindToken,
+  substitute
+} from "./chunk-LIRWLNAK.js";
+import "./chunk-IKHDUZRH.js";
 import {
   addMessage,
   createChannel,
@@ -83,12 +72,12 @@ import {
   markConversationRead,
   publish,
   subscribe as subscribe2
-} from "./chunk-FLZGS4QH.js";
+} from "./chunk-2C2VXEBB.js";
 import {
   checkForUpdate,
   checkForUpdateCached,
   getCurrentVersion
-} from "./chunk-HDN7MNGD.js";
+} from "./chunk-S5LR3XYJ.js";
 import {
   applyInitFiles,
   composeTemplate,
@@ -96,35 +85,56 @@ import {
   copyTemplateToDir,
   findTemplatesRoot,
   listFiles
-} from "./chunk-AKPFNL7L.js";
+} from "./chunk-VGWJSNHS.js";
 import {
-  getActiveMinds,
-  onMindEvent,
-  stopAll
-} from "./chunk-CQ7SNKNI.js";
+  acceptPending,
+  formatFileSize,
+  listPending,
+  rejectPending,
+  stageFile,
+  validateFilePath
+} from "./chunk-JGFRDMR6.js";
+import {
+  getCachedRecentPages,
+  getCachedSites
+} from "./chunk-EFP3PE6C.js";
+import {
+  approveUser,
+  changePassword,
+  countAdmins,
+  createUser,
+  deleteMindUser as deleteMindUser2,
+  deleteSystemsConfig,
+  deleteUser,
+  getExtensionStandardSkills,
+  getLoadedExtensions,
+  getOrCreateMindUser,
+  getUser,
+  getUserByUsername,
+  listPendingUsers,
+  listUsers,
+  listUsersByType,
+  loadAllExtensions,
+  migrateMindRoles,
+  notifyExtensionsDaemonStart,
+  notifyExtensionsDaemonStop,
+  readSystemsConfig,
+  setUserRole,
+  updateUserProfile,
+  verifyUser,
+  writeSystemsConfig
+} from "./chunk-2NDZC3S7.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";
+} from "./chunk-P27RV5WM.js";
 import {
   SEED_SKILLS,
   STANDARD_SKILLS,
   getSharedSkill,
+  getStandardSkillsWithExtensions,
   importSkillFromDir,
+  initDefaultSkills,
   installSkill,
   listFilesRecursive,
   listMindSkills,
@@ -135,15 +145,10 @@ import {
   syncBuiltinSkills,
   uninstallSkill,
   updateSkill
-} from "./chunk-NI5FFCCS.js";
+} from "./chunk-MDPCSXZ4.js";
 import {
-  acceptPending,
-  formatFileSize,
-  listPending,
-  rejectPending,
-  stageFile,
-  validateFilePath
-} from "./chunk-MD4C26II.js";
+  isHomeOnlyArchive
+} from "./chunk-DTC6EH5I.js";
 import {
   findBridgeForChannel,
   findOpenClawSession,
@@ -157,35 +162,46 @@ import {
   resolveChannelMapping,
   setBridgeConfig,
   setChannelMapping
-} from "./chunk-2YP2TVDT.js";
+} from "./chunk-UPA6COHU.js";
 import {
   loadMergedEnv,
   mindEnvPath,
   readEnv,
   sharedEnvPath,
   writeEnv
-} from "./chunk-2WPW7OT6.js";
+} from "./chunk-ZWKTUQEL.js";
+import {
+  aiComplete,
+  getAiConfig,
+  getAvailableModels,
+  getEnabledModels,
+  removeAiConfig,
+  removeProviderConfig,
+  saveProviderConfig,
+  setEnabledModels
+} from "./chunk-NSBFETWP.js";
 import {
   logBuffer,
   logger_default
 } from "./chunk-YUIHSKR6.js";
-import {
-  isHomeOnlyArchive
-} from "./chunk-XBLSAVJF.js";
 import {
   exec,
   gitExec,
   resolveVoluteBin
-} from "./chunk-AW7PFDVN.js";
+} from "./chunk-CVH6Y2YG.js";
 import {
   chownMindDir,
   createMindUser,
   deleteMindUser,
   ensureVoluteGroup,
   isIsolationEnabled,
+  mindUserName,
   wrapForIsolation
-} from "./chunk-RKQEHRBB.js";
-import "./chunk-IKRVFPWU.js";
+} from "./chunk-G3GBKZGG.js";
+import {
+  readGlobalConfig,
+  writeGlobalConfig
+} from "./chunk-7D47T4RB.js";
 import "./chunk-D424ZQGI.js";
 import {
   buildVoluteSlug,
@@ -206,9 +222,6 @@ import {
   mindDir,
   mindHistory,
   nextPort,
-  noteComments,
-  noteReactions,
-  notes,
   readAllMinds,
   readRegistry,
   removeMind,
@@ -222,14 +235,14 @@ import {
   validateMindName,
   voluteHome,
   voluteSystemDir
-} from "./chunk-H7OZRFJB.js";
+} from "./chunk-HHTXM4JT.js";
 import {
   __export
 } from "./chunk-K3NQKI34.js";
 
 // src/daemon.ts
 import { randomBytes } from "crypto";
-import { mkdirSync as mkdirSync11, readFileSync as readFileSync13, unlinkSync as unlinkSync2, writeFileSync as writeFileSync10 } from "fs";
+import { mkdirSync as mkdirSync12, readFileSync as readFileSync14, unlinkSync as unlinkSync2, writeFileSync as writeFileSync11 } from "fs";
 import { homedir as homedir2 } from "os";
 import { resolve as resolve22 } from "path";
 import { format } from "util";
@@ -818,6 +831,259 @@ function migrateToSystemDir() {
   }
 }
 
+// src/lib/shared.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync4, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolve6 } from "path";
+function readWorktreeGitDir(worktreePath) {
+  const dotGit = resolve6(worktreePath, ".git");
+  if (!existsSync6(dotGit)) return null;
+  try {
+    const content = readFileSync4(dotGit, "utf-8").trim();
+    const match = content.match(/^gitdir:\s*(.+)$/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+function sharedDir() {
+  return resolve6(voluteHome(), "shared");
+}
+async function ensureSharedRepo() {
+  const dir = sharedDir();
+  mkdirSync4(dir, { recursive: true });
+  if (existsSync6(resolve6(dir, ".git"))) {
+    try {
+      await gitExec(["rev-parse", "HEAD"], { cwd: dir });
+      return;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("unknown revision") || msg.includes("bad default revision")) {
+        logger_default.warn("shared repo has no commits, re-initializing");
+        rmSync2(resolve6(dir, ".git"), { recursive: true, force: true });
+      } else {
+        throw err;
+      }
+    }
+  }
+  const initArgs = isIsolationEnabled() ? ["init", "--shared=group"] : ["init"];
+  await gitExec(initArgs, { cwd: dir });
+  await gitExec(["checkout", "-b", "main"], { cwd: dir });
+  const pagesDir = resolve6(dir, "pages");
+  mkdirSync4(pagesDir, { recursive: true });
+  writeFileSync3(resolve6(pagesDir, ".gitkeep"), "");
+  await gitExec(["add", "-A"], { cwd: dir });
+  await gitExec(["commit", "-m", "init shared repo"], { cwd: dir });
+  if (isIsolationEnabled()) {
+    try {
+      execFileSync2("chgrp", ["-R", "volute", dir], { stdio: "ignore" });
+    } catch (err) {
+      logger_default.warn("failed to chgrp shared repo to volute group", logger_default.errorData(err));
+    }
+    chmodSync(dir, 1533);
+  }
+}
+async function addSharedWorktree(mindName, mindDir2) {
+  const dir = sharedDir();
+  if (!existsSync6(resolve6(dir, ".git"))) return;
+  const worktreePath = resolve6(mindDir2, "home", "shared");
+  if (existsSync6(worktreePath)) return;
+  let branchExists = false;
+  try {
+    await gitExec(["rev-parse", "--verify", mindName], { cwd: dir });
+    branchExists = true;
+  } catch {
+  }
+  if (branchExists) {
+    await gitExec(["worktree", "add", worktreePath, mindName], { cwd: dir });
+  } else {
+    await gitExec(["worktree", "add", "-b", mindName, worktreePath], { cwd: dir });
+  }
+  if (isIsolationEnabled()) {
+    const worktreeGitDir = readWorktreeGitDir(worktreePath);
+    if (worktreeGitDir) {
+      try {
+        const user = mindUserName(mindName);
+        execFileSync2("chown", ["-R", `${user}:volute`, worktreeGitDir], { stdio: "ignore" });
+      } catch (err) {
+        logger_default.warn(`failed to chown worktree git dir for ${mindName}`, logger_default.errorData(err));
+      }
+    }
+  }
+}
+async function removeSharedWorktree(mindName, mindDir2) {
+  const dir = sharedDir();
+  if (!existsSync6(resolve6(dir, ".git"))) return;
+  const worktreePath = resolve6(mindDir2, "home", "shared");
+  if (existsSync6(worktreePath)) {
+    try {
+      await gitExec(["worktree", "remove", "--force", worktreePath], { cwd: dir });
+    } catch (err) {
+      logger_default.debug(`worktree remove failed for ${mindName}`, logger_default.errorData(err));
+    }
+  }
+  try {
+    await gitExec(["worktree", "prune"], { cwd: dir });
+  } catch (err) {
+    logger_default.debug(`worktree prune failed for ${mindName}`, logger_default.errorData(err));
+  }
+  try {
+    await gitExec(["branch", "-D", mindName], { cwd: dir });
+  } catch {
+  }
+}
+var sharedLock = Promise.resolve();
+function rechownWorktree(worktreePath, mindName) {
+  if (!isIsolationEnabled()) return;
+  try {
+    const user = mindUserName(mindName);
+    execFileSync2("chown", ["-R", `${user}:volute`, worktreePath], { stdio: "ignore" });
+  } catch (err) {
+    logger_default.warn(`failed to rechown worktree for ${mindName}`, logger_default.errorData(err));
+  }
+}
+async function withSharedLock(fn) {
+  const prev = sharedLock;
+  let resolve_;
+  sharedLock = new Promise((r) => {
+    resolve_ = r;
+  });
+  await prev;
+  try {
+    return await fn();
+  } finally {
+    resolve_();
+  }
+}
+async function sharedMerge(mindName, mindDir2, message) {
+  return withSharedLock(async () => {
+    const dir = sharedDir();
+    const worktreePath = resolve6(mindDir2, "home", "shared");
+    const status = (await gitExec(["status", "--porcelain"], { cwd: worktreePath })).trim();
+    if (status) {
+      await gitExec(["add", "-A"], { cwd: worktreePath });
+      await gitExec(
+        ["commit", "--author", `${mindName} <${mindName}@volute>`, "-m", `wip: ${mindName}`],
+        { cwd: worktreePath }
+      );
+    }
+    const diff = (await gitExec(["diff", `main...${mindName}`, "--stat"], { cwd: dir })).trim();
+    if (!diff) {
+      return { ok: true, message: "Nothing to merge" };
+    }
+    try {
+      await gitExec(["merge", "--squash", mindName], { cwd: dir });
+    } catch {
+      try {
+        await gitExec(["reset", "--hard", "HEAD"], { cwd: dir });
+      } catch (resetErr) {
+        logger_default.error("reset after squash conflict failed in shared repo", logger_default.errorData(resetErr));
+      }
+      return { ok: false, conflicts: true, message: "Merge conflicts detected" };
+    }
+    await gitExec(["commit", "--author", `${mindName} <${mindName}@volute>`, "-m", message], {
+      cwd: dir
+    });
+    try {
+      await gitExec(["reset", "--hard", "main"], { cwd: worktreePath });
+    } catch {
+      return {
+        ok: true,
+        message: "Merged to main, but branch reset failed \u2014 run 'volute shared pull' to sync"
+      };
+    }
+    rechownWorktree(worktreePath, mindName);
+    return { ok: true };
+  });
+}
+
+// src/web/app.ts
+import { Hono as Hono29 } from "hono";
+import { bodyLimit } from "hono/body-limit";
+import { csrf } from "hono/csrf";
+import { HTTPException } from "hono/http-exception";
+
+// src/web/api/activity.ts
+import { desc } from "drizzle-orm";
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+var app = new Hono().get("/events", async (c) => {
+  const user = c.get("user");
+  return streamSSE(c, async (stream) => {
+    const cleanups = [];
+    try {
+      let recentActivity = [];
+      try {
+        const db = await getDb();
+        recentActivity = await db.select().from(activity).orderBy(desc(activity.created_at)).limit(50);
+        recentActivity = recentActivity.map((row) => ({
+          ...row,
+          metadata: row.metadata ? JSON.parse(row.metadata) : null
+        }));
+      } catch (err) {
+        logger_default.error("[activity-sse] failed to fetch recent activity", logger_default.errorData(err));
+      }
+      let conversations2 = [];
+      try {
+        conversations2 = await listConversationsWithParticipants(user.id);
+      } catch (err) {
+        logger_default.error("[activity-sse] failed to fetch conversations", logger_default.errorData(err));
+      }
+      await stream.writeSSE({
+        data: JSON.stringify({
+          event: "snapshot",
+          activity: recentActivity,
+          conversations: conversations2,
+          activeMinds: getActiveMinds()
+        })
+      });
+      const unsubActivity = subscribe((event) => {
+        stream.writeSSE({
+          data: JSON.stringify({ event: "activity", ...event })
+        }).catch((err) => {
+          if (!stream.aborted) logger_default.error("[activity-sse] write error:", logger_default.errorData(err));
+        });
+      });
+      cleanups.push(unsubActivity);
+      for (const conv of conversations2) {
+        const unsubConv = subscribe2(conv.id, (event) => {
+          stream.writeSSE({
+            data: JSON.stringify({ event: "conversation", conversationId: conv.id, ...event })
+          }).catch((err) => {
+            if (!stream.aborted) logger_default.error("[activity-sse] write error:", logger_default.errorData(err));
+          });
+        });
+        cleanups.push(unsubConv);
+      }
+      const keepAlive = setInterval(() => {
+        stream.writeSSE({ data: "" }).catch((err) => {
+          if (!stream.aborted) logger_default.error("[activity-sse] ping error:", logger_default.errorData(err));
+        });
+      }, 15e3);
+      cleanups.push(() => clearInterval(keepAlive));
+      await new Promise((resolve23) => {
+        stream.onAbort(() => resolve23());
+      });
+    } finally {
+      for (const cleanup of cleanups) {
+        try {
+          cleanup();
+        } catch {
+        }
+      }
+    }
+  });
+});
+var activity_default = app;
+
+// src/web/api/auth.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync5, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "fs";
+import { extname, resolve as resolve7 } from "path";
+import { zValidator } from "@hono/zod-validator";
+import { Hono as Hono2 } from "hono";
+import { deleteCookie, getCookie as getCookie2, setCookie } from "hono/cookie";
+import { z } from "zod";
+
 // src/web/middleware/auth.ts
 import { timingSafeEqual } from "crypto";
 import { eq as eq2, lt as lt2 } from "drizzle-orm";
@@ -939,103 +1205,7 @@ var requireSelf = (paramName = "name") => createMiddleware(async (c, next) => {
   await next();
 });
 
-// src/web/server.ts
-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 resolve21 } from "path";
-import { serve } from "@hono/node-server";
-
-// src/web/app.ts
-import { Hono as Hono30 } from "hono";
-import { bodyLimit } from "hono/body-limit";
-import { csrf } from "hono/csrf";
-import { HTTPException } from "hono/http-exception";
-
-// src/web/api/activity.ts
-import { desc } from "drizzle-orm";
-import { Hono } from "hono";
-import { streamSSE } from "hono/streaming";
-var app = new Hono().get("/events", async (c) => {
-  const user = c.get("user");
-  return streamSSE(c, async (stream) => {
-    const cleanups = [];
-    try {
-      let recentActivity = [];
-      try {
-        const db = await getDb();
-        recentActivity = await db.select().from(activity).orderBy(desc(activity.created_at)).limit(50);
-        recentActivity = recentActivity.map((row) => ({
-          ...row,
-          metadata: row.metadata ? JSON.parse(row.metadata) : null
-        }));
-      } catch (err) {
-        logger_default.error("[activity-sse] failed to fetch recent activity", logger_default.errorData(err));
-      }
-      let conversations2 = [];
-      try {
-        conversations2 = await listConversationsWithParticipants(user.id);
-      } catch (err) {
-        logger_default.error("[activity-sse] failed to fetch conversations", logger_default.errorData(err));
-      }
-      const sites = getCachedSites();
-      const recentPages = getCachedRecentPages();
-      await stream.writeSSE({
-        data: JSON.stringify({
-          event: "snapshot",
-          activity: recentActivity,
-          conversations: conversations2,
-          sites,
-          recentPages,
-          activeMinds: getActiveMinds()
-        })
-      });
-      const unsubActivity = subscribe((event) => {
-        stream.writeSSE({
-          data: JSON.stringify({ event: "activity", ...event })
-        }).catch((err) => {
-          if (!stream.aborted) logger_default.error("[activity-sse] write error:", logger_default.errorData(err));
-        });
-      });
-      cleanups.push(unsubActivity);
-      for (const conv of conversations2) {
-        const unsubConv = subscribe2(conv.id, (event) => {
-          stream.writeSSE({
-            data: JSON.stringify({ event: "conversation", conversationId: conv.id, ...event })
-          }).catch((err) => {
-            if (!stream.aborted) logger_default.error("[activity-sse] write error:", logger_default.errorData(err));
-          });
-        });
-        cleanups.push(unsubConv);
-      }
-      const keepAlive = setInterval(() => {
-        stream.writeSSE({ data: "" }).catch((err) => {
-          if (!stream.aborted) logger_default.error("[activity-sse] ping error:", logger_default.errorData(err));
-        });
-      }, 15e3);
-      cleanups.push(() => clearInterval(keepAlive));
-      await new Promise((resolve23) => {
-        stream.onAbort(() => resolve23());
-      });
-    } finally {
-      for (const cleanup of cleanups) {
-        try {
-          cleanup();
-        } catch {
-        }
-      }
-    }
-  });
-});
-var activity_default = app;
-
 // src/web/api/auth.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync4, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
-import { extname, resolve as resolve6 } from "path";
-import { zValidator } from "@hono/zod-validator";
-import { Hono as Hono2 } from "hono";
-import { deleteCookie, getCookie as getCookie2, setCookie } from "hono/cookie";
-import { z } from "zod";
 function tryJoinSystem(userId) {
   if (!process.env.VOLUTE_DAEMON_TOKEN) return;
   joinSystemChannel(userId).catch(() => {
@@ -1068,7 +1238,7 @@ var AVATAR_MIME = {
 };
 var MAX_AVATAR_SIZE = 2 * 1024 * 1024;
 function avatarsDir() {
-  return resolve6(voluteHome(), "avatars");
+  return resolve7(voluteHome(), "avatars");
 }
 var authenticated = new Hono2().use(authMiddleware).post("/change-password", zValidator("json", changePasswordSchema), async (c) => {
   const user = c.get("user");
@@ -1103,13 +1273,13 @@ var authenticated = new Hono2().use(authMiddleware).post("/change-password", zVa
     return c.json({ error: "Invalid file type (png, jpg, gif, webp only)" }, 400);
   }
   const dir = avatarsDir();
-  mkdirSync4(dir, { recursive: true });
+  mkdirSync5(dir, { recursive: true });
   const filename = `avatar-${user.id}${ext}`;
   const buffer2 = Buffer.from(await file.arrayBuffer());
-  writeFileSync3(resolve6(dir, filename), buffer2);
+  writeFileSync4(resolve7(dir, filename), buffer2);
   if (user.avatar && user.avatar !== filename) {
-    const oldPath = resolve6(dir, user.avatar);
-    rmSync2(oldPath, { force: true });
+    const oldPath = resolve7(dir, user.avatar);
+    rmSync3(oldPath, { force: true });
   }
   await updateUserProfile(user.id, { avatar: filename });
   const sessionId = getCookie2(c, "volute_session");
@@ -1123,8 +1293,8 @@ var authenticated = new Hono2().use(authMiddleware).post("/change-password", zVa
 }).delete("/avatar", async (c) => {
   const user = c.get("user");
   if (user.avatar) {
-    const path = resolve6(avatarsDir(), user.avatar);
-    rmSync2(path, { force: true });
+    const path = resolve7(avatarsDir(), user.avatar);
+    rmSync3(path, { force: true });
   }
   await updateUserProfile(user.id, { avatar: null });
   const sessionId = getCookie2(c, "volute_session");
@@ -1273,13 +1443,13 @@ var app2 = new Hono2().post("/register", zValidator("json", credentialsSchema),
     return c.json({ error: "Invalid filename" }, 400);
   }
   const dir = avatarsDir();
-  const filePath = resolve6(dir, filename);
+  const filePath = resolve7(dir, filename);
   if (!filePath.startsWith(`${dir}/`)) return c.json({ error: "Invalid path" }, 400);
-  if (!existsSync6(filePath)) return c.json({ error: "Not found" }, 404);
+  if (!existsSync7(filePath)) return c.json({ error: "Not found" }, 404);
   const ext = extname(filename).toLowerCase();
   const mime = AVATAR_MIME[ext];
   if (!mime) return c.json({ error: "Invalid file type" }, 400);
-  const data = readFileSync4(filePath);
+  const data = readFileSync5(filePath);
   return c.body(data, 200, {
     "Content-Type": mime,
     "Cache-Control": "public, max-age=3600",
@@ -1414,7 +1584,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-P5BL7RMX.js");
+    const { addParticipant } = await import("./conversations-7KVQV7EZ.js");
     await addParticipant(channel.id, puppet.id);
   }
   const contentBlocks = body.content;
@@ -1469,7 +1639,7 @@ var app3 = new Hono3().post("/:platform/inbound", zValidator2("json", inboundSch
   });
   try {
     const daemonPort = parseInt(process.env.VOLUTE_DAEMON_PORT ?? "", 10);
-    if (isNaN(daemonPort)) {
+    if (Number.isNaN(daemonPort)) {
       return c.json({ error: "VOLUTE_DAEMON_PORT not available" }, 500);
     }
     await manager.startBridge(platform, daemonPort);
@@ -1507,8 +1677,8 @@ 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-P66HQDNE.js");
-  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G4B5GW5P.js");
+  const { getMindManager: getMindManager2 } = await import("./mind-manager-YFCOIAAX.js");
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-O7YQFCV5.js");
   const manager = getMindManager2();
   const sm = getSleepManagerIfReady2();
   const targetMinds = mindParticipants.filter((ap) => {
@@ -2010,18 +2180,18 @@ __export(volute_exports, {
   read: () => read4,
   send: () => send4
 });
-import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
-import { resolve as resolve7 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
+import { resolve as resolve8 } from "path";
 function getDaemonConfig() {
-  const newPath = resolve7(voluteSystemDir(), "daemon.json");
-  const legacyPath = resolve7(voluteHome(), "daemon.json");
-  const configPath = existsSync7(newPath) ? newPath : legacyPath;
-  if (!existsSync7(configPath)) {
+  const newPath = resolve8(voluteSystemDir(), "daemon.json");
+  const legacyPath = resolve8(voluteHome(), "daemon.json");
+  const configPath = existsSync8(newPath) ? newPath : legacyPath;
+  if (!existsSync8(configPath)) {
     throw new Error("Volute daemon is not running");
   }
   let config;
   try {
-    config = JSON.parse(readFileSync5(configPath, "utf-8"));
+    config = JSON.parse(readFileSync6(configPath, "utf-8"));
   } catch (err) {
     throw new Error(`Failed to parse ${configPath}: ${err}`);
   }
@@ -2378,10 +2548,17 @@ var sharedEnvApp = new Hono5().get("/", (c) => {
 });
 var env_default = app5;
 
-// src/web/api/file-sharing.ts
-import { readFileSync as readFileSync6, statSync } from "fs";
-import { resolve as resolve8 } from "path";
+// src/web/api/extensions.ts
 import { Hono as Hono6 } from "hono";
+var app6 = new Hono6().get("/", (c) => {
+  return c.json(getLoadedExtensions());
+});
+var extensions_default = app6;
+
+// src/web/api/file-sharing.ts
+import { readFileSync as readFileSync7, statSync } from "fs";
+import { resolve as resolve9 } from "path";
+import { Hono as Hono7 } from "hono";
 async function notifyMind(port, message, channel, sender) {
   try {
     const res = await fetch(`http://127.0.0.1:${port}/message`, {
@@ -2400,7 +2577,7 @@ async function notifyMind(port, message, channel, sender) {
     console.warn(`[file-sharing] notify mind on port ${port} failed:`, err);
   }
 }
-var app6 = new Hono6().post("/:name/files/send", requireSelf(), async (c) => {
+var app7 = new Hono7().post("/:name/files/send", requireSelf(), async (c) => {
   const senderName = c.req.param("name");
   const senderEntry = await findMind(senderName);
   if (!senderEntry) return c.json({ error: "Sender mind not found" }, 404);
@@ -2413,21 +2590,21 @@ 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 = resolve8(senderDir, "home", body.filePath);
+  const filePath = resolve9(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);
-  if (stat5.size > MAX_FILE_SIZE2) {
+  const stat4 = statSync(filePath, { throwIfNoEntry: false });
+  if (!stat4) return c.json({ error: `File not found: ${body.filePath}` }, 404);
+  if (stat4.size > MAX_FILE_SIZE2) {
     return c.json(
       {
-        error: `File too large (${formatFileSize(stat5.size)}, max ${formatFileSize(MAX_FILE_SIZE2)})`
+        error: `File too large (${formatFileSize(stat4.size)}, max ${formatFileSize(MAX_FILE_SIZE2)})`
       },
       413
     );
   }
   let content;
   try {
-    content = readFileSync6(filePath);
+    content = readFileSync7(filePath);
   } catch (err) {
     const code = err.code;
     if (code === "ENOENT") {
@@ -2538,13 +2715,13 @@ var app6 = new Hono6().post("/:name/files/send", requireSelf(), async (c) => {
   }
   return c.json({ status: "pending", id }, 200);
 });
-var file_sharing_default = app6;
+var file_sharing_default = app7;
 
 // src/web/api/files.ts
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { readdir, readFile, realpath, stat } from "fs/promises";
-import { extname as extname2, resolve as resolve9 } from "path";
-import { Hono as Hono7 } from "hono";
+import { extname as extname2, resolve as resolve10 } from "path";
+import { Hono as Hono8 } from "hono";
 var ALLOWED_FILES = /* @__PURE__ */ new Set(["SOUL.md", "MEMORY.md", "CLAUDE.md", "VOLUTE.md"]);
 var AVATAR_MIME2 = {
   ".png": "image/png",
@@ -2554,7 +2731,7 @@ var AVATAR_MIME2 = {
   ".webp": "image/webp"
 };
 var MAX_AVATAR_SIZE2 = 2 * 1024 * 1024;
-var app7 = new Hono7().get("/:name/avatar", async (c) => {
+var app8 = new Hono8().get("/:name/avatar", async (c) => {
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
@@ -2564,8 +2741,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 = resolve9(dir, "home");
-  const avatarPath = resolve9(homeDir, config.profile.avatar);
+  const homeDir = resolve10(dir, "home");
+  const avatarPath = resolve10(homeDir, config.profile.avatar);
   if (!avatarPath.startsWith(`${homeDir}/`)) return c.json({ error: "Invalid avatar path" }, 400);
   let realAvatarPath;
   try {
@@ -2594,8 +2771,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 = resolve9(dir, "home");
-  if (!existsSync8(homeDir)) return c.json({ error: "Home directory missing" }, 404);
+  const homeDir = resolve10(dir, "home");
+  if (!existsSync9(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);
@@ -2608,33 +2785,33 @@ 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 = resolve9(dir, "home", filename);
-  if (!existsSync8(filePath)) {
+  const filePath = resolve10(dir, "home", filename);
+  if (!existsSync9(filePath)) {
     return c.json({ error: "File not found" }, 404);
   }
   const content = await readFile(filePath, "utf-8");
   return c.json({ filename, content });
 });
-var files_default = app7;
+var files_default = app8;
 
 // src/web/api/keys.ts
-import { Hono as Hono8 } from "hono";
+import { Hono as Hono9 } from "hono";
 
 // src/lib/identity.ts
 import { createHash, generateKeyPairSync, sign, verify } from "crypto";
-import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
-import { resolve as resolve10 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
+import { resolve as resolve11 } from "path";
 function generateIdentity(mindDir2) {
-  const identityDir = resolve10(mindDir2, ".mind/identity");
-  mkdirSync5(identityDir, { recursive: true });
+  const identityDir = resolve11(mindDir2, ".mind/identity");
+  mkdirSync6(identityDir, { recursive: true });
   const { publicKey, privateKey } = generateKeyPairSync("ed25519", {
     publicKeyEncoding: { type: "spki", format: "pem" },
     privateKeyEncoding: { type: "pkcs8", format: "pem" }
   });
-  const privatePath = resolve10(identityDir, "private.pem");
-  const publicPath = resolve10(identityDir, "public.pem");
-  writeFileSync4(privatePath, privateKey, { mode: 384 });
-  writeFileSync4(publicPath, publicKey, { mode: 420 });
+  const privatePath = resolve11(identityDir, "private.pem");
+  const publicPath = resolve11(identityDir, "public.pem");
+  writeFileSync5(privatePath, privateKey, { mode: 384 });
+  writeFileSync5(publicPath, publicKey, { mode: 420 });
   const config = readVoluteConfig(mindDir2) ?? {};
   config.identity = {
     privateKey: ".mind/identity/private.pem",
@@ -2647,17 +2824,17 @@ function getPrivateKey(mindDir2) {
   const config = readVoluteConfig(mindDir2);
   const relPath = config?.identity?.privateKey;
   if (!relPath) return null;
-  const fullPath = resolve10(mindDir2, relPath);
-  if (!existsSync9(fullPath)) return null;
-  return readFileSync7(fullPath, "utf-8");
+  const fullPath = resolve11(mindDir2, relPath);
+  if (!existsSync10(fullPath)) return null;
+  return readFileSync8(fullPath, "utf-8");
 }
 function getPublicKey(mindDir2) {
   const config = readVoluteConfig(mindDir2);
   const relPath = config?.identity?.publicKey;
   if (!relPath) return null;
-  const fullPath = resolve10(mindDir2, relPath);
-  if (!existsSync9(fullPath)) return null;
-  return readFileSync7(fullPath, "utf-8");
+  const fullPath = resolve11(mindDir2, relPath);
+  if (!existsSync10(fullPath)) return null;
+  return readFileSync8(fullPath, "utf-8");
 }
 function getFingerprint(publicKeyPem) {
   return createHash("sha256").update(publicKeyPem).digest("hex");
@@ -2692,7 +2869,7 @@ async function publishPublicKey(mindName, publicKeyPem) {
 }
 
 // src/web/api/keys.ts
-var app8 = new Hono8().get("/:fingerprint", async (c) => {
+var app9 = new Hono9().get("/:fingerprint", async (c) => {
   const fingerprint = c.req.param("fingerprint");
   for (const entry of await readRegistry()) {
     try {
@@ -2706,20 +2883,20 @@ var app8 = new Hono8().get("/:fingerprint", async (c) => {
   }
   return c.json({ error: "Key not found" }, 404);
 });
-var keys_default = app8;
+var keys_default = app9;
 
 // src/web/api/logs.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync10 } from "fs";
-import { resolve as resolve11 } from "path";
-import { Hono as Hono9 } from "hono";
+import { existsSync as existsSync11 } from "fs";
+import { resolve as resolve12 } from "path";
+import { Hono as Hono10 } from "hono";
 import { streamSSE as streamSSE2 } from "hono/streaming";
-var app9 = new Hono9().get("/:name/logs", async (c) => {
+var app10 = new Hono10().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 = resolve11(stateDir(name), "logs", "mind.log");
-  if (!existsSync10(logFile)) {
+  const logFile = resolve12(stateDir(name), "logs", "mind.log");
+  if (!existsSync11(logFile)) {
     return c.json({ error: "No log file found" }, 404);
   }
   return streamSSE2(c, async (stream) => {
@@ -2746,8 +2923,8 @@ 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 = resolve11(stateDir(name), "logs", "mind.log");
-  if (!existsSync10(logFile)) {
+  const logFile = resolve12(stateDir(name), "logs", "mind.log");
+  if (!existsSync11(logFile)) {
     return c.json({ error: "No log file found" }, 404);
   }
   const nParam = parseInt(c.req.query("n") ?? "50", 10);
@@ -2762,13 +2939,13 @@ var app9 = new Hono9().get("/:name/logs", async (c) => {
   });
   return c.text(output);
 });
-var logs_default = app9;
+var logs_default = app10;
 
 // src/web/api/mind-skills.ts
 import { zValidator as zValidator3 } from "@hono/zod-validator";
-import { Hono as Hono10 } from "hono";
+import { Hono as Hono11 } from "hono";
 import { z as z3 } from "zod";
-var app10 = new Hono10().get("/:name/skills", async (c) => {
+var app11 = new Hono11().get("/:name/skills", async (c) => {
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
@@ -2843,38 +3020,38 @@ var app10 = new Hono10().get("/:name/skills", async (c) => {
   }
   return c.json({ ok: true });
 });
-var mind_skills_default = app10;
+var mind_skills_default = app11;
 
 // src/web/api/minds.ts
 import {
   cpSync,
-  existsSync as existsSync13,
-  mkdirSync as mkdirSync8,
+  existsSync as existsSync14,
+  mkdirSync as mkdirSync9,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync11,
-  rmSync as rmSync4,
-  writeFileSync as writeFileSync8
+  readFileSync as readFileSync12,
+  rmSync as rmSync5,
+  writeFileSync as writeFileSync9
 } from "fs";
-import { resolve as resolve15 } from "path";
+import { resolve as resolve16 } from "path";
 import { zValidator as zValidator4 } from "@hono/zod-validator";
-import { and as and3, desc as desc2, eq as eq4, sql } from "drizzle-orm";
-import { Hono as Hono11 } from "hono";
+import { and as and4, desc as desc3, eq as eq5, sql as sql2 } from "drizzle-orm";
+import { Hono as Hono12 } from "hono";
 import { z as z4 } from "zod";
 
 // src/lib/consolidate.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
-import { resolve as resolve12 } from "path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
+import { resolve as resolve13 } from "path";
 async function consolidateMemory(mindDir2) {
-  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 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 logs = [];
   try {
     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 = readFileSync8(resolve12(memoryDir, filename), "utf-8").trim();
+      const content2 = readFileSync9(resolve13(memoryDir, filename), "utf-8").trim();
       if (content2) {
         logs.push(`### ${date}
 
@@ -2924,7 +3101,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) {
-    writeFileSync5(memoryPath, `${content}
+    writeFileSync6(memoryPath, `${content}
 `);
     console.log("MEMORY.md created successfully.");
   } else {
@@ -2934,11 +3111,11 @@ ${content2}`);
 
 // src/lib/convert-session.ts
 import { randomUUID } from "crypto";
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "fs";
 import { homedir } from "os";
-import { resolve as resolve13 } from "path";
+import { resolve as resolve14 } from "path";
 function convertSession(opts) {
-  const lines = readFileSync9(opts.sessionPath, "utf-8").trim().split("\n");
+  const lines = readFileSync10(opts.sessionPath, "utf-8").trim().split("\n");
   const sessionId = randomUUID();
   const idMap = /* @__PURE__ */ new Map();
   const messages = [];
@@ -3052,10 +3229,10 @@ function convertSession(opts) {
     }
   }
   const projectId = opts.projectDir.replace(/\//g, "-");
-  const sdkDir = resolve13(homedir(), ".claude", "projects", projectId);
-  mkdirSync6(sdkDir, { recursive: true });
-  const sdkPath = resolve13(sdkDir, `${sessionId}.jsonl`);
-  writeFileSync6(sdkPath, `${sdkEvents.join("\n")}
+  const sdkDir = resolve14(homedir(), ".claude", "projects", projectId);
+  mkdirSync7(sdkDir, { recursive: true });
+  const sdkPath = resolve14(sdkDir, `${sessionId}.jsonl`);
+  writeFileSync7(sdkPath, `${sdkEvents.join("\n")}
 `);
   console.log(`Converted ${sdkEvents.length} messages \u2192 ${sdkPath}`);
   return sessionId;
@@ -3100,10 +3277,198 @@ function convertAssistantContent(content) {
         caller: { type: "direct" }
       });
     } else {
-      result.push(block);
+      result.push(block);
+    }
+  }
+  return result;
+}
+
+// src/lib/daemon/turn-summarizer.ts
+import { and as and3, desc as desc2, eq as eq4, gt, lt as lt3, sql } from "drizzle-orm";
+
+// src/lib/format-tool.ts
+function summarizeTool(name, input) {
+  if (input && typeof input === "object") {
+    const args = input;
+    const val = args.path ?? args.command ?? args.query ?? args.url;
+    if (typeof val === "string") {
+      const brief = val.length > 60 ? `${val.slice(0, 57)}...` : val;
+      return `[${name} ${brief}]`;
+    }
+  }
+  return `[${name}]`;
+}
+
+// src/lib/daemon/turn-summarizer.ts
+var sLog = logger_default.child("turn-summarizer");
+async function gatherTurnEvents(mind, session, doneId) {
+  const db = await getDb();
+  const conditions = [
+    eq4(mindHistory.mind, mind),
+    eq4(mindHistory.type, "done"),
+    lt3(mindHistory.id, doneId)
+  ];
+  if (session) {
+    conditions.push(eq4(mindHistory.session, session));
+  }
+  const prevDone = await db.select({ id: mindHistory.id }).from(mindHistory).where(and3(...conditions)).orderBy(desc2(mindHistory.id)).limit(1);
+  const prevDoneId = prevDone.length > 0 ? prevDone[0].id : 0;
+  const turnConditions = [
+    eq4(mindHistory.mind, mind),
+    gt(mindHistory.id, prevDoneId),
+    sql`${mindHistory.id} <= ${doneId}`
+  ];
+  if (session) {
+    turnConditions.push(eq4(mindHistory.session, session));
+  }
+  const events = await db.select({
+    id: mindHistory.id,
+    type: mindHistory.type,
+    channel: mindHistory.channel,
+    session: mindHistory.session,
+    content: mindHistory.content,
+    metadata: mindHistory.metadata,
+    created_at: mindHistory.created_at
+  }).from(mindHistory).where(and3(...turnConditions)).orderBy(mindHistory.id);
+  return {
+    events,
+    fromId: events.length > 0 ? events[0].id : doneId,
+    toId: doneId
+  };
+}
+function buildDeterministicSummary(events) {
+  const channels = /* @__PURE__ */ new Set();
+  const tools = [];
+  let hasInbound = false;
+  let hasOutbound = false;
+  for (const ev of events) {
+    if (ev.type === "inbound") {
+      hasInbound = true;
+      if (ev.channel) channels.add(ev.channel);
+    }
+    if (ev.type === "outbound" || ev.type === "text") {
+      hasOutbound = true;
+    }
+    if (ev.type === "tool_use" && ev.metadata) {
+      try {
+        const meta = JSON.parse(ev.metadata);
+        if (meta.name) tools.push(meta.name);
+      } catch (err) {
+        sLog.debug(`failed to parse tool_use metadata for event ${ev.id}`, logger_default.errorData(err));
+      }
+    }
+  }
+  const parts = [];
+  if (hasInbound) {
+    const channelList = [...channels];
+    parts.push(
+      channelList.length > 0 ? `Received message on ${channelList.join(", ")}` : "Received message"
+    );
+  }
+  if (tools.length > 0) {
+    const unique = [...new Set(tools)];
+    parts.push(`Used ${unique.join(", ")}`);
+  }
+  if (hasOutbound) {
+    parts.push("Sent response");
+  }
+  return parts.length > 0 ? `${parts.join(". ")}.` : "Turn completed.";
+}
+function buildTranscript(events) {
+  const lines = [];
+  for (const ev of events) {
+    switch (ev.type) {
+      case "inbound":
+        lines.push(`[inbound${ev.channel ? ` ${ev.channel}` : ""}] ${ev.content ?? ""}`);
+        break;
+      case "outbound":
+      case "text":
+        lines.push(`[response] ${(ev.content ?? "").slice(0, 500)}`);
+        break;
+      case "tool_use": {
+        let toolInfo = "tool";
+        if (ev.metadata) {
+          try {
+            const meta = JSON.parse(ev.metadata);
+            toolInfo = summarizeTool(meta.name ?? "tool", meta.input ?? {});
+          } catch (err) {
+            sLog.debug(`failed to parse tool_use metadata for event ${ev.id}`, logger_default.errorData(err));
+          }
+        }
+        lines.push(toolInfo);
+        break;
+      }
+    }
+  }
+  return lines.join("\n");
+}
+async function summarizeTurn(mind, session, channel, doneId) {
+  const { events, fromId, toId } = await gatherTurnEvents(mind, session, doneId);
+  if (events.length === 0) return;
+  const tools = [];
+  for (const ev of events) {
+    if (ev.type === "tool_use" && ev.metadata) {
+      try {
+        const meta = JSON.parse(ev.metadata);
+        if (meta.name) tools.push(meta.name);
+      } catch (err) {
+        sLog.debug(`failed to parse tool_use metadata for event ${ev.id}`, logger_default.errorData(err));
+      }
+    }
+  }
+  const fromTime = events[0].created_at;
+  const toTime = events[events.length - 1].created_at;
+  let summaryText;
+  let deterministic;
+  const transcript = buildTranscript(events);
+  if (transcript.trim()) {
+    const summaryPrompt = await getPrompt("turn_summary");
+    const aiResult = await aiComplete(summaryPrompt, transcript);
+    if (aiResult) {
+      summaryText = aiResult;
+      deterministic = false;
+    } else {
+      summaryText = buildDeterministicSummary(events);
+      deterministic = true;
     }
+  } else {
+    summaryText = buildDeterministicSummary(events);
+    deterministic = true;
+  }
+  const metadata = {
+    deterministic,
+    tool_count: tools.length,
+    tools: [...new Set(tools)],
+    from_id: fromId,
+    to_id: toId,
+    from_time: fromTime,
+    to_time: toTime
+  };
+  const db = await getDb();
+  try {
+    await db.insert(mindHistory).values({
+      mind,
+      type: "summary",
+      session: session ?? null,
+      channel: channel ?? null,
+      content: summaryText,
+      metadata: JSON.stringify(metadata)
+    });
+  } catch (err) {
+    sLog.error(
+      `failed to persist summary for ${mind} (events ${fromId}-${toId})`,
+      logger_default.errorData(err)
+    );
+    return;
   }
-  return result;
+  publish2(mind, {
+    mind,
+    type: "summary",
+    session,
+    channel,
+    content: summaryText,
+    metadata
+  });
 }
 
 // src/lib/health.ts
@@ -3121,7 +3486,7 @@ async function checkHealth(port) {
 }
 
 // src/lib/variant-cleanup.ts
-import { existsSync as existsSync11, rmSync as rmSync3 } from "fs";
+import { existsSync as existsSync12, rmSync as rmSync4 } from "fs";
 async function cleanupVariant(variantName, projectRoot, variantPath, opts) {
   if (opts?.stop) {
     try {
@@ -3130,14 +3495,14 @@ async function cleanupVariant(variantName, projectRoot, variantPath, opts) {
       logger_default.warn(`failed to stop variant ${variantName}`, logger_default.errorData(err));
     }
   }
-  const { findMind: findMind2 } = await import("./registry-NDNOOYG4.js");
+  const { findMind: findMind2 } = await import("./registry-ODSALQQL.js");
   const variantEntry = await findMind2(variantName);
   const branchName = variantEntry?.branch ?? variantName;
-  if (existsSync11(variantPath)) {
+  if (existsSync12(variantPath)) {
     try {
       await gitExec(["worktree", "remove", "--force", variantPath], { cwd: projectRoot });
     } catch {
-      rmSync3(variantPath, { recursive: true, force: true });
+      rmSync4(variantPath, { recursive: true, force: true });
       try {
         await gitExec(["worktree", "prune"], { cwd: projectRoot });
       } catch (err) {
@@ -3167,8 +3532,8 @@ async function cleanupVariant(variantName, projectRoot, variantPath, opts) {
 }
 
 // src/lib/variants.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "fs";
-import { resolve as resolve14 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "fs";
+import { resolve as resolve15 } from "path";
 async function checkHealth2(port) {
   try {
     const res = await fetch(`http://127.0.0.1:${port}/health`, {
@@ -3197,7 +3562,7 @@ async function getMindStatus(name, port) {
   const manager = getMindManager();
   let status = "stopped";
   try {
-    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G4B5GW5P.js");
+    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-O7YQFCV5.js");
     if (getSleepManagerIfReady2()?.isSleeping(name)) {
       status = "sleeping";
     }
@@ -3245,7 +3610,7 @@ async function initTemplateBranch(projectRoot, composedDir, manifest, mindName,
   await gitExec(["commit", "-m", "initial commit"], opts);
 }
 async function updateTemplateBranch(projectRoot, template, mindName) {
-  const tempWorktree = resolve15(projectRoot, ".variants", "_template_update");
+  const tempWorktree = resolve16(projectRoot, ".variants", "_template_update");
   let branchExists = false;
   try {
     await gitExec(["rev-parse", "--verify", TEMPLATE_BRANCH], { cwd: projectRoot });
@@ -3256,8 +3621,8 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
     await gitExec(["worktree", "remove", "--force", tempWorktree], { cwd: projectRoot });
   } catch {
   }
-  if (existsSync13(tempWorktree)) {
-    rmSync4(tempWorktree, { recursive: true, force: true });
+  if (existsSync14(tempWorktree)) {
+    rmSync5(tempWorktree, { recursive: true, force: true });
   }
   const templatesRoot = findTemplatesRoot();
   const { composedDir, manifest } = composeTemplate(templatesRoot, template);
@@ -3277,9 +3642,9 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
       });
     }
     copyTemplateToDir(composedDir, tempWorktree, mindName, manifest);
-    const initDir = resolve15(tempWorktree, ".init");
-    if (existsSync13(initDir)) {
-      rmSync4(initDir, { recursive: true, force: true });
+    const initDir = resolve16(tempWorktree, ".init");
+    if (existsSync14(initDir)) {
+      rmSync5(initDir, { recursive: true, force: true });
     }
     await gitExec(["add", "-A"], { cwd: tempWorktree });
     try {
@@ -3292,10 +3657,10 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
       await gitExec(["worktree", "remove", "--force", tempWorktree], { cwd: projectRoot });
     } catch {
     }
-    if (existsSync13(tempWorktree)) {
-      rmSync4(tempWorktree, { recursive: true, force: true });
+    if (existsSync14(tempWorktree)) {
+      rmSync5(tempWorktree, { recursive: true, force: true });
     }
-    rmSync4(composedDir, { recursive: true, force: true });
+    rmSync5(composedDir, { recursive: true, force: true });
   }
 }
 async function mergeTemplateBranch(worktreeDir) {
@@ -3318,14 +3683,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: resolve15(cwd, "home") } });
+    await exec(cmd, args, { cwd, env: { ...process.env, HOME: resolve16(cwd, "home") } });
   } else {
     await exec("npm", ["install"], { cwd });
   }
 }
 async function importFromArchive(c, tempDir, nameOverride, manifest) {
-  const extractedMindDir = resolve15(tempDir, "mind");
-  if (!existsSync13(extractedMindDir)) {
+  const extractedMindDir = resolve16(tempDir, "mind");
+  if (!existsSync14(extractedMindDir)) {
     return c.json({ error: "Invalid archive: missing mind/ directory" }, 400);
   }
   if (!manifest?.includes || !manifest.name || !manifest.template) {
@@ -3343,21 +3708,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 (existsSync13(dest)) return c.json({ error: "Mind directory already exists" }, 409);
+  if (existsSync14(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);
-    mkdirSync8(state, { recursive: true });
-    const channelsJson = resolve15(tempDir, "state/channels.json");
-    if (existsSync13(channelsJson)) {
-      cpSync(channelsJson, resolve15(state, "channels.json"));
+    mkdirSync9(state, { recursive: true });
+    const channelsJson = resolve16(tempDir, "state/channels.json");
+    if (existsSync14(channelsJson)) {
+      cpSync(channelsJson, resolve16(state, "channels.json"));
     }
-    const envJson = resolve15(tempDir, "state/env.json");
-    if (existsSync13(envJson)) {
-      cpSync(envJson, resolve15(state, "env.json"));
+    const envJson = resolve16(tempDir, "state/env.json");
+    if (existsSync14(envJson)) {
+      cpSync(envJson, resolve16(state, "env.json"));
     }
     const port = await nextPort();
     await addMind(name, port, manifest.stage, manifest.template);
@@ -3366,36 +3731,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 = resolve15(dest, "home");
+    const homeDir = resolve16(dest, "home");
     ensureVoluteGroup();
     createMindUser(name, homeDir);
     chownMindDir(dest, name);
     await npmInstallAsMind(dest, name);
     await importHistoryFromArchive(name, tempDir);
     importSessionsFromArchive(dest, tempDir);
-    if (!existsSync13(resolve15(dest, ".git"))) {
+    if (!existsSync14(resolve16(dest, ".git"))) {
       try {
-        const env = isIsolationEnabled() ? { ...process.env, HOME: resolve15(dest, "home") } : void 0;
+        const env = isIsolationEnabled() ? { ...process.env, HOME: resolve16(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));
-        rmSync4(resolve15(dest, ".git"), { recursive: true, force: true });
+        rmSync5(resolve16(dest, ".git"), { recursive: true, force: true });
       }
     }
     chownMindDir(dest, name);
-    rmSync4(tempDir, { recursive: true, force: true });
+    rmSync5(tempDir, { recursive: true, force: true });
     return c.json({ ok: true, name, port, message: `Imported mind: ${name} (port ${port})` });
   } catch (err) {
-    if (existsSync13(dest)) rmSync4(dest, { recursive: true, force: true });
+    if (existsSync14(dest)) rmSync5(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));
     }
-    rmSync4(tempDir, { recursive: true, force: true });
+    rmSync5(tempDir, { recursive: true, force: true });
     return c.json({ error: err instanceof Error ? err.message : "Failed to import mind" }, 500);
   }
 }
@@ -3406,7 +3771,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 (existsSync13(dest)) return c.json({ error: "Mind directory already exists" }, 409);
+  if (existsSync14(dest)) return c.json({ error: "Mind directory already exists" }, 409);
   const templatesRoot = findTemplatesRoot();
   const { composedDir, manifest: templateManifest } = composeTemplate(
     templatesRoot,
@@ -3415,40 +3780,40 @@ async function importFromHomeOnlyArchive(c, tempDir, extractedMindDir, nameOverr
   try {
     copyTemplateToDir(composedDir, dest, name, templateManifest);
     applyInitFiles(dest);
-    const extractedHome = resolve15(extractedMindDir, "home");
-    if (existsSync13(extractedHome)) {
-      cpSync(extractedHome, resolve15(dest, "home"), { recursive: true });
+    const extractedHome = resolve16(extractedMindDir, "home");
+    if (existsSync14(extractedHome)) {
+      cpSync(extractedHome, resolve16(dest, "home"), { recursive: true });
     }
-    const extractedMindInternal = resolve15(extractedMindDir, ".mind");
-    if (existsSync13(extractedMindInternal)) {
-      cpSync(extractedMindInternal, resolve15(dest, ".mind"), { recursive: true });
+    const extractedMindInternal = resolve16(extractedMindDir, ".mind");
+    if (existsSync14(extractedMindInternal)) {
+      cpSync(extractedMindInternal, resolve16(dest, ".mind"), { recursive: true });
     }
-    const identityDir = resolve15(dest, ".mind/identity");
+    const identityDir = resolve16(dest, ".mind/identity");
     let publicKeyPem;
-    if (!manifest.includes.identity || !existsSync13(resolve15(identityDir, "private.pem"))) {
+    if (!manifest.includes.identity || !existsSync14(resolve16(identityDir, "private.pem"))) {
       ({ publicKeyPem } = generateIdentity(dest));
     } else {
-      publicKeyPem = readFileSync11(resolve15(identityDir, "public.pem"), "utf-8");
+      publicKeyPem = readFileSync12(resolve16(identityDir, "public.pem"), "utf-8");
     }
-    const promptsPath = resolve15(dest, "home/.config/prompts.json");
-    if (!existsSync13(promptsPath)) {
+    const promptsPath = resolve16(dest, "home/.config/prompts.json");
+    if (!existsSync14(promptsPath)) {
       const mindPrompts = await getMindPromptDefaults();
-      writeFileSync8(promptsPath, `${JSON.stringify(mindPrompts, null, 2)}
+      writeFileSync9(promptsPath, `${JSON.stringify(mindPrompts, null, 2)}
 `);
     }
     const state = stateDir(name);
-    mkdirSync8(state, { recursive: true });
-    const channelsJson = resolve15(tempDir, "state/channels.json");
-    if (existsSync13(channelsJson)) {
-      cpSync(channelsJson, resolve15(state, "channels.json"));
+    mkdirSync9(state, { recursive: true });
+    const channelsJson = resolve16(tempDir, "state/channels.json");
+    if (existsSync14(channelsJson)) {
+      cpSync(channelsJson, resolve16(state, "channels.json"));
     }
-    const envJson = resolve15(tempDir, "state/env.json");
-    if (existsSync13(envJson)) {
-      cpSync(envJson, resolve15(state, "env.json"));
+    const envJson = resolve16(tempDir, "state/env.json");
+    if (existsSync14(envJson)) {
+      cpSync(envJson, resolve16(state, "env.json"));
     }
     const port = await nextPort();
     await addMind(name, port, manifest.stage, manifest.template);
-    const homeDir = resolve15(dest, "home");
+    const homeDir = resolve16(dest, "home");
     ensureVoluteGroup();
     createMindUser(name, homeDir);
     chownMindDir(dest, name);
@@ -3461,7 +3826,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));
-      rmSync4(resolve15(dest, ".git"), { recursive: true, force: true });
+      rmSync5(resolve16(dest, ".git"), { recursive: true, force: true });
       gitWarning = "Git setup failed \u2014 variants and upgrades won't be available until git is initialized.";
     }
     try {
@@ -3469,7 +3834,7 @@ async function importFromHomeOnlyArchive(c, tempDir, extractedMindDir, nameOverr
     } catch (err) {
       logger_default.warn(`failed to add shared worktree for ${name}`, logger_default.errorData(err));
     }
-    const skillSet = manifest.stage === "seed" ? SEED_SKILLS : STANDARD_SKILLS;
+    const skillSet = manifest.stage === "seed" ? SEED_SKILLS : getStandardSkillsWithExtensions();
     const skillWarnings = [];
     for (const skillId of skillSet) {
       try {
@@ -3485,7 +3850,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 })
     );
-    rmSync4(tempDir, { recursive: true, force: true });
+    rmSync5(tempDir, { recursive: true, force: true });
     return c.json({
       ok: true,
       name,
@@ -3496,24 +3861,24 @@ async function importFromHomeOnlyArchive(c, tempDir, extractedMindDir, nameOverr
       ...skillWarnings.length > 0 && { skillWarnings }
     });
   } catch (err) {
-    if (existsSync13(dest)) rmSync4(dest, { recursive: true, force: true });
+    if (existsSync14(dest)) rmSync5(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));
     }
-    rmSync4(tempDir, { recursive: true, force: true });
+    rmSync5(tempDir, { recursive: true, force: true });
     return c.json({ error: err instanceof Error ? err.message : "Failed to import mind" }, 500);
   } finally {
-    rmSync4(composedDir, { recursive: true, force: true });
+    rmSync5(composedDir, { recursive: true, force: true });
   }
 }
 async function importHistoryFromArchive(name, tempDir) {
-  const historyJsonl = resolve15(tempDir, "history.jsonl");
-  if (!existsSync13(historyJsonl)) return;
+  const historyJsonl = resolve16(tempDir, "history.jsonl");
+  if (!existsSync14(historyJsonl)) return;
   try {
     const db = await getDb();
-    const lines = readFileSync11(historyJsonl, "utf-8").trim().split("\n");
+    const lines = readFileSync12(historyJsonl, "utf-8").trim().split("\n");
     let imported = 0;
     let failed = 0;
     for (const line of lines) {
@@ -3549,13 +3914,13 @@ async function importHistoryFromArchive(name, tempDir) {
   }
 }
 function importSessionsFromArchive(dest, tempDir) {
-  const sessionsDir = resolve15(tempDir, "sessions");
-  if (!existsSync13(sessionsDir)) return;
+  const sessionsDir = resolve16(tempDir, "sessions");
+  if (!existsSync14(sessionsDir)) return;
   try {
-    const destSessions = resolve15(dest, ".mind/sessions");
-    mkdirSync8(destSessions, { recursive: true });
+    const destSessions = resolve16(dest, ".mind/sessions");
+    mkdirSync9(destSessions, { recursive: true });
     for (const file of readdirSync3(sessionsDir)) {
-      cpSync(resolve15(sessionsDir, file), resolve15(destSessions, file));
+      cpSync(resolve16(sessionsDir, file), resolve16(destSessions, file));
     }
   } catch (err) {
     logger_default.error("Failed to import sessions from archive", logger_default.errorData(err));
@@ -3570,7 +3935,7 @@ var createMindSchema = z4.object({
   seedSoul: z4.string().optional(),
   skills: z4.array(z4.string()).optional()
 });
-var app11 = new Hono11().post("/", requireAdmin, zValidator4("json", createMindSchema), async (c) => {
+var app12 = new Hono12().post("/", requireAdmin, zValidator4("json", createMindSchema), async (c) => {
   const body = c.req.valid("json");
   const { name, template = "claude" } = body;
   const nameErr = validateMindName(name);
@@ -3578,7 +3943,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 (existsSync13(dest)) return c.json({ error: "Mind directory already exists" }, 409);
+  if (existsSync14(dest)) return c.json({ error: "Mind directory already exists" }, 409);
   const templatesRoot = findTemplatesRoot();
   const { composedDir, manifest } = composeTemplate(templatesRoot, template);
   try {
@@ -3611,15 +3976,15 @@ var app11 = new Hono11().post("/", requireAdmin, zValidator4("json", createMindS
       writeVoluteConfig(dest, config);
     }
     if (body.model) {
-      const configPath = resolve15(dest, "home/.config/config.json");
-      const existing = existsSync13(configPath) ? JSON.parse(readFileSync11(configPath, "utf-8")) : {};
+      const configPath = resolve16(dest, "home/.config/config.json");
+      const existing = existsSync14(configPath) ? JSON.parse(readFileSync12(configPath, "utf-8")) : {};
       existing.model = body.model;
-      writeFileSync8(configPath, `${JSON.stringify(existing, null, 2)}
+      writeFileSync9(configPath, `${JSON.stringify(existing, null, 2)}
 `);
     }
     const mindPrompts = await getMindPromptDefaults();
-    writeFileSync8(
-      resolve15(dest, "home/.config/prompts.json"),
+    writeFileSync9(
+      resolve16(dest, "home/.config/prompts.json"),
       `${JSON.stringify(mindPrompts, null, 2)}
 `
     );
@@ -3630,7 +3995,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 = resolve15(dest, "home");
+    const homeDir = resolve16(dest, "home");
     ensureVoluteGroup();
     createMindUser(name, homeDir);
     chownMindDir(dest, name);
@@ -3643,7 +4008,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));
-      rmSync4(resolve15(dest, ".git"), { recursive: true, force: true });
+      rmSync5(resolve16(dest, ".git"), { recursive: true, force: true });
       gitWarning = "Git setup failed \u2014 variants and upgrades won't be available until git is initialized.";
     }
     try {
@@ -3658,9 +4023,9 @@ 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;
-      writeFileSync8(resolve15(dest, "home/SOUL.md"), seedSoul);
+      writeFileSync9(resolve16(dest, "home/SOUL.md"), seedSoul);
     }
-    const skillSet = body.skills ?? (body.stage === "seed" ? SEED_SKILLS : STANDARD_SKILLS);
+    const skillSet = body.skills ?? (body.stage === "seed" ? SEED_SKILLS : getStandardSkillsWithExtensions());
     const skillWarnings = [];
     for (const skillId of skillSet) {
       try {
@@ -3673,11 +4038,11 @@ The human who planted you described you as: "${body.description}"
     if (body.stage !== "seed") {
       const customSoul = await getPromptIfCustom("default_soul");
       if (customSoul) {
-        writeFileSync8(resolve15(dest, "home/SOUL.md"), customSoul.replace(/\{\{name\}\}/g, name));
+        writeFileSync9(resolve16(dest, "home/SOUL.md"), customSoul.replace(/\{\{name\}\}/g, name));
       }
       const customMemory = await getPromptIfCustom("default_memory");
       if (customMemory) {
-        writeFileSync8(resolve15(dest, "home/MEMORY.md"), customMemory);
+        writeFileSync9(resolve16(dest, "home/MEMORY.md"), customMemory);
       }
     }
     publishPublicKey(name, publicKeyPem).catch(
@@ -3706,14 +4071,14 @@ The human who planted you described you as: "${body.description}"
       ...skillWarnings.length > 0 && { skillWarnings }
     });
   } catch (err) {
-    if (existsSync13(dest)) rmSync4(dest, { recursive: true, force: true });
+    if (existsSync14(dest)) rmSync5(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 {
-    rmSync4(composedDir, { recursive: true, force: true });
+    rmSync5(composedDir, { recursive: true, force: true });
   }
 }).post("/import", requireAdmin, async (c) => {
   let body;
@@ -3726,13 +4091,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 || !existsSync13(resolve15(wsDir, "SOUL.md")) || !existsSync13(resolve15(wsDir, "IDENTITY.md"))) {
+  if (!wsDir || !existsSync14(resolve16(wsDir, "SOUL.md")) || !existsSync14(resolve16(wsDir, "IDENTITY.md"))) {
     return c.json({ error: "Invalid workspace: missing SOUL.md or IDENTITY.md" }, 400);
   }
-  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 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 name = body.name ?? parseNameFromIdentity(identity) ?? "imported-mind";
   const template = body.template ?? "claude";
   const nameErr = validateMindName(name);
@@ -3752,33 +4117,33 @@ ${user.trimEnd()}
 ` : "";
   ensureVoluteHome();
   const dest = mindDir(name);
-  if (existsSync13(dest)) return c.json({ error: "Mind directory already exists" }, 409);
+  if (existsSync14(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);
-    writeFileSync8(resolve15(dest, "home/SOUL.md"), mergedSoul);
-    const wsMemoryPath = resolve15(wsDir, "MEMORY.md");
-    const hasMemory = existsSync13(wsMemoryPath);
+    writeFileSync9(resolve16(dest, "home/SOUL.md"), mergedSoul);
+    const wsMemoryPath = resolve16(wsDir, "MEMORY.md");
+    const hasMemory = existsSync14(wsMemoryPath);
     if (hasMemory) {
-      const existingMemory = readFileSync11(wsMemoryPath, "utf-8");
-      writeFileSync8(
-        resolve15(dest, "home/MEMORY.md"),
+      const existingMemory = readFileSync12(wsMemoryPath, "utf-8");
+      writeFileSync9(
+        resolve16(dest, "home/MEMORY.md"),
         `${existingMemory.trimEnd()}${mergedMemoryExtra}`
       );
     } else if (user) {
-      writeFileSync8(resolve15(dest, "home/MEMORY.md"), `${user.trimEnd()}
+      writeFileSync9(resolve16(dest, "home/MEMORY.md"), `${user.trimEnd()}
 `);
     }
-    const wsMemoryDir = resolve15(wsDir, "memory");
+    const wsMemoryDir = resolve16(wsDir, "memory");
     let dailyLogCount = 0;
-    if (existsSync13(wsMemoryDir)) {
-      const destMemoryDir = resolve15(dest, "home/memory");
+    if (existsSync14(wsMemoryDir)) {
+      const destMemoryDir = resolve16(dest, "home/memory");
       const files = readdirSync3(wsMemoryDir).filter((f) => f.endsWith(".md"));
       for (const file of files) {
-        cpSync(resolve15(wsMemoryDir, file), resolve15(destMemoryDir, file));
+        cpSync(resolve16(wsMemoryDir, file), resolve16(destMemoryDir, file));
       }
       dailyLogCount = files.length;
     }
@@ -3789,7 +4154,7 @@ ${user.trimEnd()}
     } catch (err) {
       logger_default.warn(`failed to set template hash for ${name}`, logger_default.errorData(err));
     }
-    const homeDir = resolve15(dest, "home");
+    const homeDir = resolve16(dest, "home");
     ensureVoluteGroup();
     createMindUser(name, homeDir);
     chownMindDir(dest, name);
@@ -3797,20 +4162,20 @@ ${user.trimEnd()}
     if (!hasMemory && dailyLogCount > 0) {
       await consolidateMemory(dest);
     }
-    const env = isIsolationEnabled() ? { ...process.env, HOME: resolve15(dest, "home") } : void 0;
+    const env = isIsolationEnabled() ? { ...process.env, HOME: resolve16(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 ? resolve15(body.sessionPath) : findOpenClawSession(wsDir);
-    if (sessionFile && existsSync13(sessionFile)) {
+    const sessionFile = body.sessionPath ? resolve16(body.sessionPath) : findOpenClawSession(wsDir);
+    if (sessionFile && existsSync14(sessionFile)) {
       if (template === "pi") {
         importPiSession(sessionFile, dest);
       } else if (template === "claude") {
         const sessionId = convertSession({ sessionPath: sessionFile, projectDir: dest });
-        const mindRuntimeDir = resolve15(dest, ".mind");
-        mkdirSync8(mindRuntimeDir, { recursive: true });
-        writeFileSync8(resolve15(mindRuntimeDir, "session.json"), JSON.stringify({ sessionId }));
+        const mindRuntimeDir = resolve16(dest, ".mind");
+        mkdirSync9(mindRuntimeDir, { recursive: true });
+        writeFileSync9(resolve16(mindRuntimeDir, "session.json"), JSON.stringify({ sessionId }));
       }
     }
     importOpenClawConnectors(name, dest);
@@ -3825,14 +4190,14 @@ ${user.trimEnd()}
     );
     return c.json({ ok: true, name, port, message: `Imported mind: ${name} (port ${port})` });
   } catch (err) {
-    if (existsSync13(dest)) rmSync4(dest, { recursive: true, force: true });
+    if (existsSync14(dest)) rmSync5(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 {
-    rmSync4(composedDir, { recursive: true, force: true });
+    rmSync5(composedDir, { recursive: true, force: true });
   }
 }).get("/", async (c) => {
   const entries = await readRegistry();
@@ -3841,7 +4206,7 @@ ${user.trimEnd()}
     const db = await getDb();
     const lastActiveRows = await db.select({
       mind: mindHistory.mind,
-      lastActiveAt: sql`MAX(${mindHistory.created_at})`
+      lastActiveAt: sql2`MAX(${mindHistory.created_at})`
     }).from(mindHistory).groupBy(mindHistory.mind);
     lastActiveMap = new Map(lastActiveRows.map((r) => [r.mind, r.lastActiveAt]));
   } catch {
@@ -3849,7 +4214,7 @@ ${user.trimEnd()}
   const minds = await Promise.all(
     entries.map(async (entry) => {
       const mindStatus = await getMindStatus(entry.name, entry.port);
-      const hasPages = existsSync13(resolve15(mindDir(entry.name), "home", "public", "pages"));
+      const hasPages = existsSync14(resolve16(mindDir(entry.name), "home", "public", "pages"));
       return {
         ...entry,
         ...mindStatus,
@@ -3868,7 +4233,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 (!existsSync13(dir)) return c.json({ error: "Mind directory missing" }, 404);
+  if (!existsSync14(dir)) return c.json({ error: "Mind directory missing" }, 404);
   const mindStatus = await getMindStatus(name, entry.port);
   const variants = await findVariants(name);
   const manager = getMindManager();
@@ -3882,7 +4247,7 @@ ${user.trimEnd()}
       return { name: s.name, port: s.port, status: variantStatus };
     })
   );
-  const hasPages = existsSync13(resolve15(mindDir(name), "home", "public", "pages"));
+  const hasPages = existsSync14(resolve16(mindDir(name), "home", "public", "pages"));
   return c.json({ ...entry, ...mindStatus, variants: variantStatuses, hasPages });
 }).post("/:name/start", requireSelf(), async (c) => {
   const name = c.req.param("name");
@@ -3893,7 +4258,7 @@ ${user.trimEnd()}
     if (!entry.dir) return c.json({ error: `Variant ${name} has no directory` }, 404);
   } else {
     const dir = mindDir(name);
-    if (!existsSync13(dir)) return c.json({ error: "Mind directory missing" }, 404);
+    if (!existsSync14(dir)) return c.json({ error: "Mind directory missing" }, 404);
   }
   if (getMindManager().isRunning(name)) {
     return c.json({ error: "Mind already running" }, 409);
@@ -3914,7 +4279,7 @@ ${user.trimEnd()}
     if (!entry.dir) return c.json({ error: `Variant ${name} has no directory` }, 404);
   } else {
     const dir = mindDir(name);
-    if (!existsSync13(dir)) return c.json({ error: "Mind directory missing" }, 404);
+    if (!existsSync14(dir)) return c.json({ error: "Mind directory missing" }, 404);
   }
   let context;
   const contentType = c.req.header("content-type");
@@ -3929,7 +4294,7 @@ ${user.trimEnd()}
   const manager = getMindManager();
   try {
     if (context?.type === "reload") {
-      const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G4B5GW5P.js");
+      const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-O7YQFCV5.js");
       const sleepState = getSleepManagerIfReady2()?.getState(name);
       if (sleepState?.sleeping) {
         logger_default.info(`skipping reload for ${name} during sleep \u2014 will apply on next wake`);
@@ -3949,7 +4314,7 @@ ${user.trimEnd()}
       const variantEntry = await findMind(mergeVariantName);
       if (variantEntry && variantEntry.parent === baseName && variantEntry.dir && variantEntry.branch) {
         const projectRoot = mindDir(baseName);
-        if (existsSync13(variantEntry.dir)) {
+        if (existsSync14(variantEntry.dir)) {
           const status = (await gitExec(["status", "--porcelain"], { cwd: variantEntry.dir })).trim();
           if (status) {
             try {
@@ -3991,7 +4356,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(eq4(conversations.mind_name, baseName)).all();
+        const activeConvs = await db.select({ id: conversations.id }).from(conversations).where(eq5(conversations.mind_name, baseName)).all();
         for (const conv of activeConvs) {
           await addMessage(conv.id, "assistant", "system", [
             { type: "text", text: "[seed has sprouted]" }
@@ -4024,7 +4389,7 @@ ${user.trimEnd()}
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G4B5GW5P.js");
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-O7YQFCV5.js");
   const sm = getSleepManagerIfReady2();
   if (!sm) return c.json({ error: "Sleep manager not initialized" }, 503);
   return c.json(sm.getState(name));
@@ -4032,7 +4397,7 @@ ${user.trimEnd()}
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G4B5GW5P.js");
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-O7YQFCV5.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);
@@ -4052,7 +4417,7 @@ ${user.trimEnd()}
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G4B5GW5P.js");
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-O7YQFCV5.js");
   const sm = getSleepManagerIfReady2();
   if (!sm) return c.json({ error: "Sleep manager not initialized" }, 503);
   const sleepState = sm.getState(name);
@@ -4067,7 +4432,7 @@ ${user.trimEnd()}
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G4B5GW5P.js");
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-O7YQFCV5.js");
   const sm = getSleepManagerIfReady2();
   if (!sm) return c.json({ error: "Sleep manager not initialized" }, 503);
   const flushed = await sm.flushQueuedMessages(name);
@@ -4105,11 +4470,11 @@ ${user.trimEnd()}
   await removeMind(name);
   await deleteMindUser2(name);
   const state = stateDir(name);
-  if (existsSync13(state)) {
-    rmSync4(state, { recursive: true, force: true });
+  if (existsSync14(state)) {
+    rmSync5(state, { recursive: true, force: true });
   }
-  if (force && existsSync13(dir)) {
-    rmSync4(dir, { recursive: true, force: true });
+  if (force && existsSync14(dir)) {
+    rmSync5(dir, { recursive: true, force: true });
     deleteMindUser(name);
   }
   fireWebhook({
@@ -4123,7 +4488,7 @@ ${user.trimEnd()}
   const entry = await findMind(mindName);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const dir = mindDir(mindName);
-  if (!existsSync13(dir)) return c.json({ error: "Mind directory missing" }, 404);
+  if (!existsSync14(dir)) return c.json({ error: "Mind directory missing" }, 404);
   let body = {};
   try {
     body = await c.req.json();
@@ -4132,16 +4497,16 @@ ${user.trimEnd()}
   const template = body.template ?? entry.template ?? "claude";
   const UPGRADE_BRANCH = "upgrade";
   const upgradeVariantName = `${mindName}-upgrade`;
-  const worktreeDir = resolve15(dir, ".variants", UPGRADE_BRANCH);
+  const worktreeDir = resolve16(dir, ".variants", UPGRADE_BRANCH);
   if (body.abort) {
-    if (!existsSync13(worktreeDir)) {
+    if (!existsSync14(worktreeDir)) {
       return c.json({ error: "No upgrade in progress" }, 400);
     }
     try {
       try {
-        const gitDirContent = readFileSync11(resolve15(worktreeDir, ".git"), "utf-8").trim();
+        const gitDirContent = readFileSync12(resolve16(worktreeDir, ".git"), "utf-8").trim();
         const gitDir = gitDirContent.replace("gitdir: ", "");
-        if (existsSync13(resolve15(gitDir, "MERGE_HEAD"))) {
+        if (existsSync14(resolve16(gitDir, "MERGE_HEAD"))) {
           await gitExec(["merge", "--abort"], { cwd: worktreeDir });
         }
       } catch {
@@ -4160,7 +4525,7 @@ ${user.trimEnd()}
     }
   }
   if (body.continue) {
-    if (!existsSync13(worktreeDir)) {
+    if (!existsSync14(worktreeDir)) {
       return c.json({ error: "No upgrade in progress" }, 400);
     }
     const status = await gitExec(["status", "--porcelain"], { cwd: worktreeDir });
@@ -4199,7 +4564,7 @@ ${user.trimEnd()}
     }
   }
   if (body.accept) {
-    if (!existsSync13(worktreeDir)) {
+    if (!existsSync14(worktreeDir)) {
       return c.json({ error: "No upgrade in progress" }, 400);
     }
     const variantEntry = await findMind(upgradeVariantName);
@@ -4222,7 +4587,7 @@ ${user.trimEnd()}
       try {
         await gitExec(["add", "-A"], { cwd: dir });
         await gitExec(["commit", "-m", "Auto-commit before upgrade merge"], { cwd: dir });
-      } catch (e) {
+      } catch (_e) {
         return c.json({ error: "Failed to auto-commit main changes before merge" }, 500);
       }
     }
@@ -4257,22 +4622,22 @@ ${user.trimEnd()}
     }
     return c.json({ ok: true });
   }
-  if (existsSync13(worktreeDir)) {
+  if (existsSync14(worktreeDir)) {
     return c.json(
       { error: "Upgrade variant already exists. Use continue or delete it first." },
       409
     );
   }
-  if (!existsSync13(resolve15(dir, ".git"))) {
+  if (!existsSync14(resolve16(dir, ".git"))) {
     try {
-      const env = isIsolationEnabled() ? { ...process.env, HOME: resolve15(dir, "home") } : void 0;
+      const env = isIsolationEnabled() ? { ...process.env, HOME: resolve16(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) {
-      rmSync4(resolve15(dir, ".git"), { recursive: true, force: true });
+      rmSync5(resolve16(dir, ".git"), { recursive: true, force: true });
       return c.json(
         {
           error: `Git initialization failed: ${err instanceof Error ? err.message : String(err)}`
@@ -4286,7 +4651,7 @@ ${user.trimEnd()}
     await gitExec(["branch", "-D", UPGRADE_BRANCH], { cwd: dir });
   } catch {
   }
-  if (!existsSync13(resolve15(dir, "home", "shared"))) {
+  if (!existsSync14(resolve16(dir, "home", "shared"))) {
     try {
       await addSharedWorktree(mindName, dir);
     } catch (err) {
@@ -4297,9 +4662,9 @@ ${user.trimEnd()}
     }
   }
   await updateTemplateBranch(dir, template, mindName);
-  const parentDir = resolve15(dir, ".variants");
-  if (!existsSync13(parentDir)) {
-    mkdirSync8(parentDir, { recursive: true });
+  const parentDir = resolve16(dir, ".variants");
+  if (!existsSync14(parentDir)) {
+    mkdirSync9(parentDir, { recursive: true });
   }
   await gitExec(["worktree", "add", "-b", UPGRADE_BRANCH, worktreeDir], { cwd: dir });
   const hasConflicts = await mergeTemplateBranch(worktreeDir);
@@ -4336,7 +4701,7 @@ ${user.trimEnd()}
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const baseName = entry.parent ?? name;
   try {
-    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G4B5GW5P.js");
+    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-O7YQFCV5.js");
     const sm = getSleepManagerIfReady2();
     if (sm?.isSleeping(baseName)) {
       const body2 = await c.req.text();
@@ -4434,7 +4799,7 @@ ${user.trimEnd()}
   if (seedEntry?.stage === "seed") {
     try {
       const db = await getDb();
-      const countResult = await db.select({ count: sql`count(*)` }).from(mindHistory).where(eq4(mindHistory.mind, baseName));
+      const countResult = await db.select({ count: sql2`count(*)` }).from(mindHistory).where(eq5(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.]";
@@ -4491,7 +4856,7 @@ ${user.trimEnd()}
   }
   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)) {
+  if (before !== void 0 && Number.isNaN(before) || limit !== void 0 && Number.isNaN(limit)) {
     return c.json({ error: "Invalid pagination parameters" }, 400);
   }
   const result = await getMessagesPaginated(convId, { before, limit });
@@ -4507,13 +4872,13 @@ ${user.trimEnd()}
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const dir = mindDir(name);
-  if (!existsSync13(dir)) return c.json({ error: "Mind directory missing" }, 404);
+  if (!existsSync14(dir)) return c.json({ error: "Mind directory missing" }, 404);
   let config = readVoluteConfig(dir);
   if (!config && entry.template === "pi") {
-    const piConfigPath = resolve15(dir, "home/.config/config.json");
-    if (existsSync13(piConfigPath)) {
+    const piConfigPath = resolve16(dir, "home/.config/config.json");
+    if (existsSync14(piConfigPath)) {
       try {
-        config = JSON.parse(readFileSync11(piConfigPath, "utf-8"));
+        config = JSON.parse(readFileSync12(piConfigPath, "utf-8"));
       } catch {
       }
     }
@@ -4550,7 +4915,7 @@ ${user.trimEnd()}
     const entry = await findMind(name);
     if (!entry) return c.json({ error: "Mind not found" }, 404);
     const dir = mindDir(name);
-    if (!existsSync13(dir)) return c.json({ error: "Mind directory missing" }, 404);
+    if (!existsSync14(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;
@@ -4587,6 +4952,20 @@ ${user.trimEnd()}
     logger_default.error(`failed to get pending deliveries for ${baseName}`, logger_default.errorData(err));
     return c.json({ error: "Failed to retrieve pending messages" }, 500);
   }
+}).post("/:name/ai/complete", requireSelf(), async (c) => {
+  const body = await c.req.json();
+  if (!body.systemPrompt || !body.message) {
+    return c.json({ error: "systemPrompt and message required" }, 400);
+  }
+  const { aiComplete: aiCompleteFn, isAiConfigured } = await import("./ai-service-VAJT5UBS.js");
+  if (!isAiConfigured()) {
+    return c.json({ error: "AI service not configured" }, 503);
+  }
+  const text = await aiCompleteFn(body.systemPrompt, body.message, body.model);
+  if (text == null) {
+    return c.json({ error: "AI completion failed" }, 502);
+  }
+  return c.json({ text });
 }).post("/:name/events", requireSelf(), async (c) => {
   const name = c.req.param("name");
   const baseName = await getBaseName(name);
@@ -4600,8 +4979,9 @@ ${user.trimEnd()}
     return c.json({ error: "type required" }, 400);
   }
   const db = await getDb();
+  let insertedId;
   try {
-    await db.insert(mindHistory).values({
+    const result = await db.insert(mindHistory).values({
       mind: baseName,
       type: body.type,
       session: body.session ?? null,
@@ -4609,7 +4989,8 @@ ${user.trimEnd()}
       message_id: body.messageId ?? null,
       content: body.content ?? null,
       metadata: body.metadata ? JSON.stringify(body.metadata) : null
-    });
+    }).returning({ id: mindHistory.id });
+    insertedId = result[0]?.id;
   } catch (err) {
     logger_default.error(`failed to persist event for ${baseName}`, logger_default.errorData(err));
   }
@@ -4640,6 +5021,11 @@ ${user.trimEnd()}
         logger_default.error(`delivery manager sessionDone failed for ${baseName}`, logger_default.errorData(err));
       }
     }
+    if (insertedId != null) {
+      summarizeTurn(baseName, body.session, body.channel, insertedId).catch((err) => {
+        logger_default.error("turn summarization failed", logger_default.errorData(err));
+      });
+    }
   }
   if (body.type === "usage" && body.metadata) {
     const inputTokens = body.metadata.input_tokens ?? 0;
@@ -4731,22 +5117,22 @@ ${user.trimEnd()}
   const db = await getDb();
   const rows = await db.select({
     session: mindHistory.session,
-    started_at: sql`MIN(${mindHistory.created_at})`,
-    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(and3(eq4(mindHistory.mind, name), sql`${mindHistory.session} IS NOT NULL`)).groupBy(mindHistory.session).orderBy(sql`MIN(${mindHistory.created_at}) DESC`);
+    started_at: sql2`MIN(${mindHistory.created_at})`,
+    event_count: sql2`COUNT(*)`,
+    message_count: sql2`SUM(CASE WHEN ${mindHistory.type} IN ('inbound','outbound') THEN 1 ELSE 0 END)`,
+    tool_count: sql2`SUM(CASE WHEN ${mindHistory.type}='tool_use' THEN 1 ELSE 0 END)`
+  }).from(mindHistory).where(and4(eq5(mindHistory.mind, name), sql2`${mindHistory.session} IS NOT NULL`)).groupBy(mindHistory.session).orderBy(sql2`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(eq4(mindHistory.mind, name));
+  const rows = await db.selectDistinct({ channel: mindHistory.channel }).from(mindHistory).where(eq5(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(eq4(mindHistory.mind, name));
+  const rows = await db.select().from(mindHistory).where(eq5(mindHistory.mind, name));
   return c.json(rows);
 }).get("/:name/history", async (c) => {
   const name = c.req.param("name");
@@ -4756,391 +5142,27 @@ ${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 = [eq4(mindHistory.mind, name)];
+  const conditions = [eq5(mindHistory.mind, name)];
   if (channel) {
-    conditions.push(eq4(mindHistory.channel, channel));
+    conditions.push(eq5(mindHistory.channel, channel));
   }
   if (session) {
-    conditions.push(eq4(mindHistory.session, session));
+    conditions.push(eq5(mindHistory.session, session));
   }
   if (!full) {
-    conditions.push(sql`${mindHistory.type} IN ('inbound', 'outbound')`);
+    conditions.push(sql2`${mindHistory.type} IN ('inbound', 'outbound', 'summary')`);
   }
-  const rows = await db.select().from(mindHistory).where(and3(...conditions)).orderBy(desc2(mindHistory.created_at)).limit(limit).offset(offset);
+  const rows = await db.select().from(mindHistory).where(and4(...conditions)).orderBy(desc3(mindHistory.created_at)).limit(limit).offset(offset);
   return c.json(rows);
 });
-var minds_default = app11;
-
-// src/web/api/notes.ts
-import { zValidator as zValidator5 } from "@hono/zod-validator";
-import { Hono as Hono12 } from "hono";
-import { z as z5 } from "zod";
-
-// src/lib/notes.ts
-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(eq5(notes.author_id, authorId)).all();
-  const existingSlugs = new Set(existing.map((r) => r.slug));
-  if (existingSlugs.has(slug)) {
-    let i = 2;
-    while (existingSlugs.has(`${slug}-${i}`)) i++;
-    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(eq5(users.id, authorId)).get();
-  return {
-    ...row,
-    author_username: author?.username ?? "unknown",
-    author_display_name: author?.display_name ?? null,
-    comment_count: 0
-  };
-}
-async function getNote(authorUsername, slug) {
-  const db = await getDb();
-  const row = await db.select({
-    id: notes.id,
-    author_id: notes.author_id,
-    title: notes.title,
-    slug: notes.slug,
-    content: notes.content,
-    reply_to_id: notes.reply_to_id,
-    created_at: notes.created_at,
-    updated_at: notes.updated_at,
-    author_username: users.username,
-    author_display_name: users.display_name
-  }).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);
-  let reply_to = null;
-  if (row.reply_to_id) {
-    const parent = await db.select({
-      title: notes.title,
-      slug: notes.slug,
-      author_username: users.username
-    }).from(notes).innerJoin(users, eq5(notes.author_id, users.id)).where(eq5(notes.id, row.reply_to_id)).get();
-    if (parent) {
-      reply_to = parent;
-    }
-  }
-  const replies = await db.select({
-    author_username: users.username,
-    slug: notes.slug,
-    title: notes.title,
-    created_at: notes.created_at
-  }).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) {
-  const db = await getDb();
-  const limit = opts?.limit ?? 50;
-  const offset = opts?.offset ?? 0;
-  const conditions = [];
-  if (opts?.authorUsername) {
-    conditions.push(eq5(users.username, opts.authorUsername));
-  }
-  const rows = await db.select({
-    id: notes.id,
-    author_id: notes.author_id,
-    title: notes.title,
-    slug: notes.slug,
-    content: notes.content,
-    reply_to_id: notes.reply_to_id,
-    created_at: notes.created_at,
-    updated_at: notes.updated_at,
-    author_username: users.username,
-    author_display_name: users.display_name
-  }).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({
-    note_id: noteComments.note_id,
-    count: count()
-  }).from(noteComments).where(inArray(noteComments.note_id, noteIds)).groupBy(noteComments.note_id).all();
-  const countMap = new Map(commentCounts.map((r) => [r.note_id, r.count]));
-  const allReactions = await db.select({
-    note_id: noteReactions.note_id,
-    emoji: noteReactions.emoji,
-    count: count()
-  }).from(noteReactions).where(inArray(noteReactions.note_id, noteIds)).groupBy(noteReactions.note_id, noteReactions.emoji).all();
-  const reactionMap = /* @__PURE__ */ new Map();
-  for (const r of allReactions) {
-    if (!reactionMap.has(r.note_id)) reactionMap.set(r.note_id, []);
-    reactionMap.get(r.note_id).push({ emoji: r.emoji, count: r.count });
-  }
-  const replyToIds = [...new Set(rows.filter((r) => r.reply_to_id).map((r) => r.reply_to_id))];
-  const replyToMap = /* @__PURE__ */ new Map();
-  if (replyToIds.length > 0) {
-    const parents = await db.select({
-      id: notes.id,
-      title: notes.title,
-      slug: notes.slug,
-      author_username: users.username
-    }).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,
-        slug: parent.slug,
-        title: parent.title
-      });
-    }
-  }
-  return rows.map((r) => {
-    const reactions = reactionMap.get(r.id);
-    const topReactions = reactions ? reactions.sort((a, b) => b.count - a.count).slice(0, 3).map((rx) => ({ ...rx, usernames: [] })) : void 0;
-    return {
-      ...r,
-      comment_count: countMap.get(r.id) ?? 0,
-      reactions: topReactions,
-      reply_to: r.reply_to_id ? replyToMap.get(r.reply_to_id) ?? null : null
-    };
-  });
-}
-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, 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(eq5(notes.id, existing.id));
-  return getNote(authorUsername, slug).then((n) => {
-    if (!n) return null;
-    const { comments, replies, ...note } = n;
-    return note;
-  });
-}
-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, 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(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(eq5(users.id, authorId)).get();
-  return {
-    ...row,
-    author_username: author?.username ?? "unknown",
-    author_display_name: author?.display_name ?? null
-  };
-}
-async function getComments(noteId) {
-  const db = await getDb();
-  return db.select({
-    id: noteComments.id,
-    note_id: noteComments.note_id,
-    author_id: noteComments.author_id,
-    content: noteComments.content,
-    created_at: noteComments.created_at,
-    author_username: users.username,
-    author_display_name: users.display_name
-  }).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(eq5(noteComments.id, commentId)).get();
-  if (!existing || existing.author_id !== authorId) return false;
-  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(
-    and4(
-      eq5(noteReactions.note_id, noteId),
-      eq5(noteReactions.user_id, userId),
-      eq5(noteReactions.emoji, emoji)
-    )
-  ).get();
-  if (existing) {
-    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 });
-  return { added: true };
-}
-async function getReactions(noteId) {
-  const db = await getDb();
-  const rows = await db.select({
-    emoji: noteReactions.emoji,
-    username: users.username
-  }).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, []);
-    grouped.get(r.emoji).push(r.username);
-  }
-  return [...grouped.entries()].map(([emoji, usernames]) => ({
-    emoji,
-    count: usernames.length,
-    usernames
-  }));
-}
-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, eq5(notes.author_id, users.id)).where(and4(eq5(users.username, author), eq5(notes.slug, slug))).get();
-  return row?.id ?? null;
-}
-
-// src/web/api/notes.ts
-var createSchema = z5.object({
-  title: z5.string().min(1).max(200),
-  content: z5.string().min(1),
-  reply_to: z5.string().optional()
-});
-var updateSchema = z5.object({
-  title: z5.string().min(1).max(200).optional(),
-  content: z5.string().min(1).optional()
-});
-var commentSchema = z5.object({
-  content: z5.string().min(1)
-});
-var reactionSchema = z5.object({
-  emoji: z5.string().min(1).max(32)
-});
-function resolveUserId(c) {
-  const user = c.get("user");
-  if (user.id === 0) return null;
-  return { id: user.id, username: user.username };
-}
-var app12 = new Hono12().get("/", async (c) => {
-  const author = c.req.query("author");
-  const limit = c.req.query("limit") ? parseInt(c.req.query("limit"), 10) : void 0;
-  const offset = c.req.query("offset") ? parseInt(c.req.query("offset"), 10) : void 0;
-  const result = await listNotes({ authorUsername: author, limit, offset });
-  return c.json(result);
-}).post("/", zValidator5("json", createSchema), async (c) => {
-  const actor = resolveUserId(c);
-  if (!actor) return c.json({ error: "Unauthorized" }, 401);
-  const { title, content, reply_to } = c.req.valid("json");
-  let replyToId;
-  if (reply_to) {
-    const id = await resolveNoteId(reply_to);
-    if (id === null) return c.json({ error: `Reply target not found: ${reply_to}` }, 404);
-    replyToId = id;
-  }
-  const note = await createNote(actor.id, title, content, replyToId);
-  const replyInfo = reply_to ? ` (in reply to ${reply_to})` : "";
-  announceToSystem(`${actor.username} published a note: ${title}${replyInfo}`).catch((err) => {
-    logger_default.warn("failed to announce note to #system", logger_default.errorData(err));
-  });
-  return c.json(note, 201);
-}).get("/:author/:slug", async (c) => {
-  const { author, slug } = c.req.param();
-  const note = await getNote(author, slug);
-  if (!note) return c.json({ error: "Note not found" }, 404);
-  return c.json(note);
-}).put("/:author/:slug", zValidator5("json", updateSchema), async (c) => {
-  const actor = resolveUserId(c);
-  if (!actor) return c.json({ error: "Unauthorized" }, 401);
-  const { author, slug } = c.req.param();
-  if (actor.username !== author) return c.json({ error: "Forbidden" }, 403);
-  const updates = c.req.valid("json");
-  const note = await updateNote(author, slug, updates);
-  if (!note) return c.json({ error: "Note not found" }, 404);
-  return c.json(note);
-}).delete("/:author/:slug", async (c) => {
-  const actor = resolveUserId(c);
-  if (!actor) return c.json({ error: "Unauthorized" }, 401);
-  const { author, slug } = c.req.param();
-  const deleted = await deleteNote(author, slug, actor.id);
-  if (!deleted) return c.json({ error: "Note not found or not authorized" }, 404);
-  return c.json({ ok: true });
-}).post("/:author/:slug/reactions", zValidator5("json", reactionSchema), async (c) => {
-  const actor = resolveUserId(c);
-  if (!actor) return c.json({ error: "Unauthorized" }, 401);
-  const { author, slug } = c.req.param();
-  const note = await getNote(author, slug);
-  if (!note) return c.json({ error: "Note not found" }, 404);
-  const { emoji } = c.req.valid("json");
-  const result = await toggleReaction(note.id, actor.id, emoji);
-  const reactions = await getReactions(note.id);
-  return c.json({ ...result, reactions });
-}).post("/:author/:slug/comments", zValidator5("json", commentSchema), async (c) => {
-  const actor = resolveUserId(c);
-  if (!actor) return c.json({ error: "Unauthorized" }, 401);
-  const { author, slug } = c.req.param();
-  const note = await getNote(author, slug);
-  if (!note) return c.json({ error: "Note not found" }, 404);
-  const { content } = c.req.valid("json");
-  const comment = await addComment(note.id, actor.id, content);
-  return c.json(comment, 201);
-}).delete("/:author/:slug/comments/:id", async (c) => {
-  const actor = resolveUserId(c);
-  if (!actor) return c.json({ error: "Unauthorized" }, 401);
-  const commentId = parseInt(c.req.param("id"), 10);
-  if (Number.isNaN(commentId)) return c.json({ error: "Invalid comment ID" }, 400);
-  const deleted = await deleteComment(commentId, actor.id);
-  if (!deleted) return c.json({ error: "Comment not found or not authorized" }, 404);
-  return c.json({ ok: true });
-});
-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 resolve16 } from "path";
-import { Hono as Hono13 } from "hono";
-var MIME_TYPES = {
-  ".html": "text/html",
-  ".js": "application/javascript",
-  ".css": "text/css",
-  ".json": "application/json",
-  ".svg": "image/svg+xml",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".ico": "image/x-icon",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".txt": "text/plain",
-  ".xml": "application/xml"
-};
-var app13 = new Hono13().get("/:name/*", async (c) => {
-  const name = c.req.param("name");
-  let pagesRoot;
-  if (name === "_system") {
-    pagesRoot = resolve16(voluteHome(), "shared", "pages");
-  } else {
-    if (!await findMind(name)) return c.text("Not found", 404);
-    pagesRoot = resolve16(mindDir(name), "home", "public", "pages");
-  }
-  const wildcard = c.req.path.replace(`/pages/${name}`, "") || "/";
-  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 = resolve16(requestedPath, "index.html");
-    fileStat = await stat2(indexPath).catch(() => null);
-    if (fileStat?.isFile()) {
-      const body = await readFile2(indexPath);
-      return c.body(body, 200, { "Content-Type": "text/html" });
-    }
-    return c.text("Not found", 404);
-  }
-  if (fileStat?.isFile()) {
-    const ext = extname3(requestedPath);
-    const mime = MIME_TYPES[ext] || "application/octet-stream";
-    const body = await readFile2(requestedPath);
-    return c.body(body, 200, { "Content-Type": mime });
-  }
-  return c.text("Not found", 404);
-});
-var pages_default = app13;
+var minds_default = app12;
 
 // src/web/api/prompts.ts
-import { zValidator as zValidator6 } from "@hono/zod-validator";
+import { zValidator as zValidator5 } from "@hono/zod-validator";
 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) => {
+import { Hono as Hono13 } from "hono";
+import { z as z5 } from "zod";
+var app13 = new Hono13().get("/", async (c) => {
   let rows;
   try {
     const db = await getDb();
@@ -5163,7 +5185,7 @@ var app14 = new Hono14().get("/", async (c) => {
     };
   });
   return c.json(prompts);
-}).put("/:key", requireAdmin, zValidator6("json", z6.object({ content: z6.string() })), async (c) => {
+}).put("/:key", requireAdmin, zValidator5("json", z5.object({ content: z5.string() })), async (c) => {
   const key = c.req.param("key");
   if (!PROMPT_KEYS.includes(key)) {
     return c.json({ error: "Unknown prompt key" }, 404);
@@ -5184,12 +5206,12 @@ var app14 = new Hono14().get("/", async (c) => {
   await db.delete(systemPrompts).where(eq6(systemPrompts.key, key));
   return c.json({ ok: true });
 });
-var prompts_default = app14;
+var prompts_default = app13;
 
 // 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 resolve17 } from "path";
-import { Hono as Hono15 } from "hono";
+import { readdir as readdir2, readFile as readFile2, stat as stat2 } from "fs/promises";
+import { extname as extname3, resolve as resolve17 } from "path";
+import { Hono as Hono14 } from "hono";
 var MAX_FILE_SIZE = 50 * 1024 * 1024;
 async function resolvePublicRoot(name) {
   if (name === "_system") return resolve17(voluteHome(), "shared");
@@ -5199,7 +5221,7 @@ async function resolvePublicRoot(name) {
 function hasDotSegment(relativePath) {
   return relativePath.split("/").some((seg) => seg.startsWith("."));
 }
-var MIME_TYPES2 = {
+var MIME_TYPES = {
   ".html": "text/html",
   ".js": "application/javascript",
   ".css": "text/css",
@@ -5230,7 +5252,7 @@ async function listDir(dirPath) {
     type: e.isDirectory() ? "directory" : "file"
   }));
 }
-var app15 = new Hono15().get("/:name/", async (c) => {
+var app14 = new Hono14().get("/:name/", async (c) => {
   const name = c.req.param("name");
   const publicRoot = await resolvePublicRoot(name);
   if (!publicRoot) return c.json({ error: "Not found" }, 404);
@@ -5246,7 +5268,7 @@ var app15 = new Hono15().get("/:name/", async (c) => {
   if (hasDotSegment(relativePath)) return c.text("Forbidden", 403);
   let fileStat;
   try {
-    fileStat = await stat3(requestedPath);
+    fileStat = await stat2(requestedPath);
   } catch (err) {
     if (err?.code === "ENOENT") return c.text("Not found", 404);
     if (err?.code === "EACCES") return c.text("Forbidden", 403);
@@ -5260,10 +5282,10 @@ var app15 = new Hono15().get("/:name/", async (c) => {
   }
   if (fileStat.isFile()) {
     if (fileStat.size > MAX_FILE_SIZE) return c.text("File too large", 413);
-    const ext = extname4(requestedPath);
-    const mime = MIME_TYPES2[ext] || "application/octet-stream";
+    const ext = extname3(requestedPath);
+    const mime = MIME_TYPES[ext] || "application/octet-stream";
     try {
-      const body = await readFile3(requestedPath);
+      const body = await readFile2(requestedPath);
       return c.body(body, 200, { "Content-Type": mime });
     } catch (err) {
       if (err?.code === "ENOENT") return c.text("Not found", 404);
@@ -5273,11 +5295,11 @@ var app15 = new Hono15().get("/:name/", async (c) => {
   }
   return c.text("Not found", 404);
 });
-var public_files_default = app15;
+var public_files_default = app14;
 
 // src/web/api/schedules.ts
 import { CronExpressionParser } from "cron-parser";
-import { Hono as Hono16 } from "hono";
+import { Hono as Hono15 } from "hono";
 var slog = logger_default.child("schedules");
 function readSchedules(name) {
   return readVoluteConfig(mindDir(name))?.schedules ?? [];
@@ -5295,7 +5317,7 @@ function writeSchedules(name, schedules) {
     data: { schedules }
   });
 }
-var app16 = new Hono16().get("/:name/clock/status", async (c) => {
+var app15 = new Hono15().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();
@@ -5337,6 +5359,9 @@ var app16 = new Hono16().get("/:name/clock/status", async (c) => {
   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.id) {
+    return c.json({ error: "id is required (a descriptive name for this schedule)" }, 400);
+  }
   if (!body.cron && !body.fireAt) {
     return c.json({ error: "cron or fireAt is required" }, 400);
   }
@@ -5368,7 +5393,7 @@ var app16 = new Hono16().get("/:name/clock/status", async (c) => {
     );
   }
   const schedules = readSchedules(name);
-  const id = body.id || `schedule-${Date.now()}`;
+  const id = body.id;
   if (schedules.some((s) => s.id === id)) {
     return c.json({ error: `Schedule "${id}" already exists` }, 409);
   }
@@ -5468,11 +5493,11 @@ var app16 = new Hono16().get("/:name/clock/status", async (c) => {
     return c.json({ error: "Failed to reach mind" }, 502);
   }
 });
-var schedules_default = app16;
+var schedules_default = app15;
 
 // src/web/api/shared.ts
-import { Hono as Hono17 } from "hono";
-var app17 = new Hono17().post("/:name/shared/merge", requireAdmin, async (c) => {
+import { Hono as Hono16 } from "hono";
+var app16 = new Hono16().post("/:name/shared/merge", requireAdmin, async (c) => {
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
@@ -5490,24 +5515,63 @@ var app17 = new Hono17().post("/:name/shared/merge", requireAdmin, async (c) =>
     return c.json({ error: err instanceof Error ? err.message : "Merge failed" }, 500);
   }
 });
-var shared_default = app17;
+var shared_default = app16;
 
 // src/web/api/skills.ts
-import { existsSync as existsSync14, mkdtempSync, readdirSync as readdirSync4, rmSync as rmSync5 } from "fs";
+import { existsSync as existsSync15, mkdtempSync, readdirSync as readdirSync4, rmSync as rmSync6 } from "fs";
 import { tmpdir } from "os";
 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) => {
+import { Hono as Hono17 } from "hono";
+var app17 = new Hono17().get("/", async (c) => {
   const skills = await listSharedSkills();
   return c.json(skills);
-}).get("/:id", 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 = join(sharedSkillsDir(), id);
-  const files = listFilesRecursive(dir);
-  return c.json({ ...skill, files });
+}).get("/defaults/list", async (c) => {
+  return c.json({ skills: getStandardSkillsWithExtensions() });
+}).put("/defaults/list", requireAdmin, async (c) => {
+  const body = await c.req.json();
+  if (!Array.isArray(body.skills) || !body.skills.every((s) => typeof s === "string")) {
+    return c.json({ error: "body.skills must be a string array" }, 400);
+  }
+  const config = readGlobalConfig();
+  const allStandard = /* @__PURE__ */ new Set([...STANDARD_SKILLS, ...getExtensionStandardSkills()]);
+  const newSet = new Set(body.skills);
+  const removed = [...allStandard].filter((s) => !newSet.has(s));
+  const prevRemoved = new Set(config.removedDefaultSkills ?? []);
+  for (const s of removed) prevRemoved.add(s);
+  for (const s of body.skills) prevRemoved.delete(s);
+  writeGlobalConfig({
+    ...config,
+    defaultSkills: body.skills,
+    removedDefaultSkills: [...prevRemoved]
+  });
+  return c.json({ skills: body.skills });
+}).post("/defaults/list", requireAdmin, async (c) => {
+  const body = await c.req.json();
+  if (typeof body.skill !== "string" || !body.skill) {
+    return c.json({ error: "body.skill must be a non-empty string" }, 400);
+  }
+  const current = getStandardSkillsWithExtensions();
+  if (current.includes(body.skill)) {
+    return c.json({ error: `"${body.skill}" is already a default skill` }, 409);
+  }
+  const config = readGlobalConfig();
+  const updated = [...current, body.skill];
+  const removed = (config.removedDefaultSkills ?? []).filter((s) => s !== body.skill);
+  writeGlobalConfig({ ...config, defaultSkills: updated, removedDefaultSkills: removed });
+  return c.json({ skills: updated });
+}).delete("/defaults/list/:skill", requireAdmin, async (c) => {
+  const skill = c.req.param("skill");
+  const current = getStandardSkillsWithExtensions();
+  if (!current.includes(skill)) {
+    return c.json({ error: `"${skill}" is not a default skill` }, 404);
+  }
+  const config = readGlobalConfig();
+  const updated = current.filter((s) => s !== skill);
+  const removed = new Set(config.removedDefaultSkills ?? []);
+  removed.add(skill);
+  writeGlobalConfig({ ...config, defaultSkills: updated, removedDefaultSkills: [...removed] });
+  return c.json({ skills: updated });
 }).post("/upload", requireAdmin, async (c) => {
   const body = await c.req.parseBody();
   const file = body.file;
@@ -5529,12 +5593,12 @@ var app18 = new Hono18().get("/", async (c) => {
     }
     zip.extractAllTo(tmpDir, true);
     let skillDir = null;
-    if (existsSync14(join(tmpDir, "SKILL.md"))) {
+    if (existsSync15(join(tmpDir, "SKILL.md"))) {
       skillDir = tmpDir;
     } else {
       const entries = readdirSync4(tmpDir, { withFileTypes: true }).filter((e) => e.isDirectory());
       for (const entry of entries) {
-        if (existsSync14(join(tmpDir, entry.name, "SKILL.md"))) {
+        if (existsSync15(join(tmpDir, entry.name, "SKILL.md"))) {
           skillDir = join(tmpDir, entry.name);
           break;
         }
@@ -5551,8 +5615,15 @@ var app18 = new Hono18().get("/", async (c) => {
     }
     throw e;
   } finally {
-    rmSync5(tmpDir, { recursive: true, force: true });
+    rmSync6(tmpDir, { recursive: true, force: true });
   }
+}).get("/:id", 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 = join(sharedSkillsDir(), id);
+  const files = listFilesRecursive(dir);
+  return c.json({ ...skill, files });
 }).delete("/:id", requireAdmin, async (c) => {
   const id = c.req.param("id");
   try {
@@ -5563,15 +5634,16 @@ var app18 = new Hono18().get("/", async (c) => {
   }
   return c.json({ ok: true });
 });
-var skills_default = app18;
+var skills_default = app17;
 
 // src/web/api/system.ts
-import { zValidator as zValidator7 } from "@hono/zod-validator";
-import { Hono as Hono19 } from "hono";
+import { zValidator as zValidator6 } from "@hono/zod-validator";
+import { getOAuthProvider, getOAuthProviders, getProviders } from "@mariozechner/pi-ai";
+import { Hono as Hono18 } from "hono";
 import { streamSSE as streamSSE3 } from "hono/streaming";
-import { z as z7 } from "zod";
+import { z as z6 } from "zod";
 var DEFAULT_API_URL = "https://volute.systems";
-var app19 = new Hono19().post("/restart", requireAdmin, (c) => {
+var app18 = new Hono18().post("/restart", requireAdmin, (c) => {
   setTimeout(() => process.exit(1), 200);
   return c.json({ ok: true });
 }).post("/stop", requireAdmin, (c) => {
@@ -5601,7 +5673,7 @@ var app19 = new Hono19().post("/restart", requireAdmin, (c) => {
 }).post(
   "/register",
   requireAdmin,
-  zValidator7("json", z7.object({ name: z7.string().min(1) })),
+  zValidator6("json", z6.object({ name: z6.string().min(1) })),
   async (c) => {
     const existing = readSystemsConfig();
     if (existing) {
@@ -5640,7 +5712,7 @@ var app19 = new Hono19().post("/restart", requireAdmin, (c) => {
 ).post(
   "/login",
   requireAdmin,
-  zValidator7("json", z7.object({ key: z7.string().min(1) })),
+  zValidator6("json", z6.object({ key: z6.string().min(1) })),
   async (c) => {
     const existing = readSystemsConfig();
     if (existing) {
@@ -5708,19 +5780,173 @@ var app19 = new Hono19().post("/restart", requireAdmin, (c) => {
   } catch (err) {
     return c.json({ error: `Connection failed: ${err.message}` }, 502);
   }
+}).get("/ai/providers", requireAdmin, (c) => {
+  const allProviders = getProviders();
+  const oauthProviders = getOAuthProviders();
+  const oauthMap = new Map(oauthProviders.map((p) => [p.id, p]));
+  const ai = getAiConfig();
+  const result = allProviders.map((id) => {
+    const oauth = oauthMap.get(id);
+    const providerConfig = ai?.providers[id];
+    const configured = !!(providerConfig?.apiKey || providerConfig?.oauth);
+    let authMethod = null;
+    if (providerConfig?.oauth) authMethod = "oauth";
+    else if (providerConfig?.apiKey) authMethod = "api_key";
+    return {
+      id,
+      oauth: !!oauth,
+      oauthName: oauth?.name,
+      usesCallbackServer: !!oauth?.usesCallbackServer,
+      configured,
+      authMethod
+    };
+  });
+  return c.json(result);
+}).get("/ai/models", requireAdmin, (c) => {
+  const models = getAvailableModels();
+  const enabled = new Set(getEnabledModels());
+  return c.json(
+    models.map((m) => ({
+      id: m.id,
+      name: m.name,
+      provider: m.provider,
+      contextWindow: m.contextWindow,
+      maxTokens: m.maxTokens,
+      enabled: enabled.has(m.id)
+    }))
+  );
+}).put(
+  "/ai/models",
+  requireAdmin,
+  zValidator6("json", z6.object({ models: z6.array(z6.string()) })),
+  (c) => {
+    const { models } = c.req.valid("json");
+    setEnabledModels(models);
+    return c.json({ ok: true });
+  }
+).put(
+  "/ai/providers/:id",
+  requireAdmin,
+  zValidator6("json", z6.object({ apiKey: z6.string().min(1) })),
+  (c) => {
+    const id = c.req.param("id");
+    const { apiKey } = c.req.valid("json");
+    saveProviderConfig(id, { apiKey });
+    return c.json({ ok: true });
+  }
+).delete("/ai/providers/:id", requireAdmin, (c) => {
+  const id = c.req.param("id");
+  removeProviderConfig(id);
+  return c.json({ ok: true });
+}).delete("/ai", requireAdmin, (c) => {
+  removeAiConfig();
+  return c.json({ ok: true });
+}).post(
+  "/ai/oauth/start",
+  requireAdmin,
+  zValidator6("json", z6.object({ provider: z6.string().min(1) })),
+  async (c) => {
+    const { provider } = c.req.valid("json");
+    const oauthProvider = getOAuthProvider(provider);
+    if (!oauthProvider) {
+      return c.json({ error: `OAuth not supported for provider: ${provider}` }, 400);
+    }
+    cleanupOAuthFlows();
+    const flowId = crypto.randomUUID();
+    const needsManualCode = !!oauthProvider.usesCallbackServer;
+    const flow = {
+      status: "pending",
+      needsManualCode,
+      createdAt: Date.now()
+    };
+    oauthFlows.set(flowId, flow);
+    const promptPromise = needsManualCode ? new Promise((resolve23) => {
+      flow.resolveCode = resolve23;
+    }) : void 0;
+    oauthProvider.login({
+      onAuth: (info) => {
+        const existing = oauthFlows.get(flowId);
+        if (existing)
+          Object.assign(existing, { url: info.url, instructions: info.instructions });
+      },
+      onPrompt: async (_prompt) => {
+        if (promptPromise) {
+          const existing = oauthFlows.get(flowId);
+          if (existing) existing.waitingForCode = true;
+          return promptPromise;
+        }
+        return "";
+      },
+      onManualCodeInput: needsManualCode ? () => promptPromise : void 0
+    }).then((credentials) => {
+      saveProviderConfig(provider, { oauth: credentials });
+      const existing = oauthFlows.get(flowId);
+      if (existing) existing.status = "complete";
+    }).catch((err) => {
+      const existing = oauthFlows.get(flowId);
+      if (existing) {
+        existing.status = "error";
+        existing.error = err instanceof Error ? err.message : String(err);
+      }
+    });
+    await new Promise((resolve23) => setTimeout(resolve23, 2e3));
+    const state = oauthFlows.get(flowId);
+    return c.json({
+      flowId,
+      url: state.url,
+      instructions: state.instructions,
+      needsManualCode
+    });
+  }
+).post(
+  "/ai/oauth/code/:flowId",
+  requireAdmin,
+  zValidator6("json", z6.object({ code: z6.string().min(1) })),
+  async (c) => {
+    const flowId = c.req.param("flowId");
+    const flow = oauthFlows.get(flowId);
+    if (!flow) return c.json({ error: "Flow not found" }, 404);
+    if (!flow.resolveCode) return c.json({ error: "Flow does not accept manual code" }, 400);
+    const { code } = c.req.valid("json");
+    flow.resolveCode(code.trim());
+    return c.json({ ok: true });
+  }
+).get("/ai/oauth/status/:flowId", requireAdmin, (c) => {
+  const flowId = c.req.param("flowId");
+  const flow = oauthFlows.get(flowId);
+  if (!flow) return c.json({ error: "Flow not found" }, 404);
+  const result = {
+    status: flow.status,
+    waitingForCode: flow.waitingForCode
+  };
+  if (flow.error) result.error = flow.error;
+  if (flow.status !== "pending") {
+    setTimeout(() => oauthFlows.delete(flowId), 3e4);
+  }
+  return c.json(result);
 });
-var system_default = app19;
+var oauthFlows = /* @__PURE__ */ new Map();
+var OAUTH_FLOW_TTL_MS = 10 * 60 * 1e3;
+function cleanupOAuthFlows() {
+  const now = Date.now();
+  for (const [id, flow] of oauthFlows) {
+    if (now - flow.createdAt > OAUTH_FLOW_TTL_MS) {
+      oauthFlows.delete(id);
+    }
+  }
+}
+var system_default = app18;
 
 // src/web/api/typing.ts
-import { zValidator as zValidator8 } from "@hono/zod-validator";
-import { Hono as Hono20 } from "hono";
-import { z as z8 } from "zod";
-var typingSchema = z8.object({
-  channel: z8.string().min(1),
-  sender: z8.string().min(1),
-  active: z8.boolean()
+import { zValidator as zValidator7 } from "@hono/zod-validator";
+import { Hono as Hono19 } from "hono";
+import { z as z7 } from "zod";
+var typingSchema = z7.object({
+  channel: z7.string().min(1),
+  sender: z7.string().min(1),
+  active: z7.boolean()
 });
-var app20 = new Hono20().post("/:name/typing", zValidator8("json", typingSchema), (c) => {
+var app19 = new Hono19().post("/:name/typing", zValidator7("json", typingSchema), (c) => {
   const { channel, sender, active } = c.req.valid("json");
   const map = getTypingMap();
   if (active) {
@@ -5742,13 +5968,13 @@ var app20 = new Hono20().post("/:name/typing", zValidator8("json", typingSchema)
   const map = getTypingMap();
   return c.json({ typing: map.get(channel) });
 });
-var typing_default = app20;
+var typing_default = app19;
 
 // src/web/api/update.ts
 import { spawn as spawn3 } from "child_process";
-import { Hono as Hono21 } from "hono";
+import { Hono as Hono20 } from "hono";
 var bin;
-var app21 = new Hono21().get("/update", async (c) => {
+var app20 = new Hono20().get("/update", async (c) => {
   const result = await checkForUpdate();
   return c.json(result);
 }).post("/update", requireAdmin, async (c) => {
@@ -5763,21 +5989,21 @@ var app21 = new Hono21().get("/update", async (c) => {
   child.unref();
   return c.json({ ok: true, message: "Updating..." });
 });
-var update_default = app21;
+var update_default = app20;
 
 // src/web/api/v1/chat.ts
-import { zValidator as zValidator9 } from "@hono/zod-validator";
-import { Hono as Hono22 } from "hono";
+import { zValidator as zValidator8 } from "@hono/zod-validator";
+import { Hono as Hono21 } from "hono";
 import { streamSSE as streamSSE4 } from "hono/streaming";
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 async function fanOutToMinds(opts) {
   const participants = await getParticipants(opts.conversationId);
   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" : "channel");
-  const { getMindManager: getMindManager2 } = await import("./mind-manager-P66HQDNE.js");
-  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-G4B5GW5P.js");
+  const { getMindManager: getMindManager2 } = await import("./mind-manager-YFCOIAAX.js");
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-O7YQFCV5.js");
   const manager = getMindManager2();
   const sm = getSleepManagerIfReady2();
   const targetMinds = mindParticipants.map((ap) => {
@@ -5826,18 +6052,18 @@ async function fanOutToMinds(opts) {
     });
   }
 }
-var mindChatSchema = z9.object({
-  message: z9.string().optional(),
-  conversationId: z9.string().optional(),
-  sender: z9.string().optional(),
-  images: z9.array(z9.object({ media_type: z9.string(), data: z9.string() })).optional()
+var mindChatSchema = z8.object({
+  message: z8.string().optional(),
+  conversationId: z8.string().optional(),
+  sender: z8.string().optional(),
+  images: z8.array(z8.object({ media_type: z8.string(), data: z8.string() })).optional()
 });
-var unifiedChatSchema = z9.object({
-  message: z9.string().optional(),
-  conversationId: z9.string(),
-  images: z9.array(z9.object({ media_type: z9.string(), data: z9.string() })).optional()
+var unifiedChatSchema = z8.object({
+  message: z8.string().optional(),
+  conversationId: z8.string(),
+  images: z8.array(z8.object({ media_type: z8.string(), data: z8.string() })).optional()
 });
-var app22 = new Hono22().use("*", authMiddleware).post("/minds/:name/chat", zValidator9("json", mindChatSchema), async (c) => {
+var app21 = new Hono21().use("*", authMiddleware).post("/minds/:name/chat", zValidator8("json", mindChatSchema), async (c) => {
   const name = c.req.param("name");
   const baseName = await getBaseName(name);
   const entry = await findMind(baseName);
@@ -5928,7 +6154,7 @@ var app22 = new Hono22().use("*", authMiddleware).post("/minds/:name/chat", zVal
       });
     });
   });
-}).post("/chat", zValidator9("json", unifiedChatSchema), async (c) => {
+}).post("/chat", zValidator8("json", unifiedChatSchema), async (c) => {
   const user = c.get("user");
   const body = c.req.valid("json");
   if (!body.message && (!body.images || body.images.length === 0)) {
@@ -5960,17 +6186,17 @@ var app22 = new Hono22().use("*", authMiddleware).post("/minds/:name/chat", zVal
   });
   return c.json({ ok: true, conversationId: body.conversationId });
 });
-var chat_default = app22;
+var chat_default = app21;
 
 // src/web/api/v1/conversations.ts
-import { zValidator as zValidator10 } from "@hono/zod-validator";
-import { Hono as Hono23 } from "hono";
-import { z as z10 } from "zod";
-var createSchema2 = z10.object({
-  title: z10.string().optional(),
-  participantNames: z10.array(z10.string()).min(1)
+import { zValidator as zValidator9 } from "@hono/zod-validator";
+import { Hono as Hono22 } from "hono";
+import { z as z9 } from "zod";
+var createSchema = z9.object({
+  title: z9.string().optional(),
+  participantNames: z9.array(z9.string()).min(1)
 });
-var app23 = new Hono23().use("*", authMiddleware).get("/", async (c) => {
+var app22 = new Hono22().use("*", authMiddleware).get("/", async (c) => {
   const user = c.get("user");
   const convs = await listConversationsWithParticipants(user.id);
   return c.json(convs);
@@ -5988,7 +6214,7 @@ var app23 = new Hono23().use("*", authMiddleware).get("/", async (c) => {
   }
   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)) {
+  if (before !== void 0 && Number.isNaN(before) || limit !== void 0 && Number.isNaN(limit)) {
     return c.json({ error: "Invalid cursor params: before and limit must be integers" }, 400);
   }
   const result = await getMessagesPaginated(id, { before, limit });
@@ -6001,7 +6227,7 @@ var app23 = new Hono23().use("*", authMiddleware).get("/", async (c) => {
   }
   const participants = await getParticipants(id);
   return c.json(participants);
-}).post("/", zValidator10("json", createSchema2), async (c) => {
+}).post("/", zValidator9("json", createSchema), async (c) => {
   const user = c.get("user");
   const body = c.req.valid("json");
   const participantIds = /* @__PURE__ */ new Set();
@@ -6047,30 +6273,30 @@ var app23 = new Hono23().use("*", authMiddleware).get("/", async (c) => {
   if (!deleted) return c.json({ error: "Conversation not found" }, 404);
   return c.json({ ok: true });
 });
-var conversations_default = app23;
+var conversations_default = app22;
 
 // src/web/api/v1/events.ts
 import { desc as desc4 } from "drizzle-orm";
-import { Hono as Hono24 } from "hono";
+import { Hono as Hono23 } from "hono";
 import { streamSSE as streamSSE5 } from "hono/streaming";
 
 // src/lib/events/brain-presence.ts
 var connections = /* @__PURE__ */ new Map();
 function addConnection(username) {
-  const count2 = connections.get(username) ?? 0;
-  connections.set(username, count2 + 1);
-  if (count2 === 0) {
+  const count = connections.get(username) ?? 0;
+  connections.set(username, count + 1);
+  if (count === 0) {
     broadcast({ type: "brain_online", mind: username, summary: `${username} connected` });
   }
 }
 function removeConnection(username) {
-  const count2 = connections.get(username);
-  if (count2 == null) return;
-  if (count2 <= 1) {
+  const count = connections.get(username);
+  if (count == null) return;
+  if (count <= 1) {
     connections.delete(username);
     broadcast({ type: "brain_offline", mind: username, summary: `${username} disconnected` });
   } else {
-    connections.set(username, count2 - 1);
+    connections.set(username, count - 1);
   }
 }
 function getOnlineBrains() {
@@ -6098,7 +6324,7 @@ function getEventsSince(sinceId) {
 }
 
 // src/web/api/v1/events.ts
-var app24 = new Hono24().use("*", authMiddleware).get("/", async (c) => {
+var app23 = new Hono23().use("*", authMiddleware).get("/", async (c) => {
   const user = c.get("user");
   const since = c.req.query("since");
   const sinceId = since ? Number(since) : 0;
@@ -6205,16 +6431,16 @@ var app24 = new Hono24().use("*", authMiddleware).get("/", async (c) => {
     }
   });
 });
-var events_default = app24;
+var events_default = app23;
 
 // src/web/api/variants.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync10, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync11, writeFileSync as writeFileSync10 } from "fs";
 import { resolve as resolve20 } from "path";
-import { Hono as Hono25 } from "hono";
+import { Hono as Hono24 } from "hono";
 
 // src/lib/spawn-server.ts
 import { spawn as spawn4 } from "child_process";
-import { closeSync, mkdirSync as mkdirSync9, openSync, readFileSync as readFileSync12 } from "fs";
+import { closeSync, mkdirSync as mkdirSync10, openSync, readFileSync as readFileSync13 } from "fs";
 import { resolve as resolve19 } from "path";
 function tsxBin(cwd) {
   return resolve19(cwd, "node_modules", ".bin", "tsx");
@@ -6253,7 +6479,7 @@ function spawnAttached(cwd, port) {
 }
 function spawnDetached(cwd, port, logDir) {
   const logsDir = logDir ?? resolve19(cwd, ".mind", "logs");
-  mkdirSync9(logsDir, { recursive: true });
+  mkdirSync10(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)], {
@@ -6274,7 +6500,7 @@ function spawnDetached(cwd, port, logDir) {
     }
     const interval = setInterval(() => {
       try {
-        const content = readFileSync12(logPath, "utf-8");
+        const content = readFileSync13(logPath, "utf-8");
         const match = content.match(/listening on :(\d+)/);
         if (match) {
           finish({ child, actualPort: parseInt(match[1], 10) });
@@ -6326,7 +6552,7 @@ async function verify2(port) {
 }
 
 // src/web/api/variants.ts
-var app25 = new Hono25().get("/:name/variants", async (c) => {
+var app24 = new Hono24().get("/:name/variants", async (c) => {
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
@@ -6371,10 +6597,10 @@ var app25 = new Hono25().get("/:name/variants", async (c) => {
   }
   const projectRoot = mindDir(mindName);
   const variantDir = resolve20(projectRoot, ".variants", variantName);
-  if (existsSync15(variantDir)) {
+  if (existsSync16(variantDir)) {
     return c.json({ error: `Variant directory already exists: ${variantDir}` }, 409);
   }
-  mkdirSync10(resolve20(projectRoot, ".variants"), { recursive: true });
+  mkdirSync11(resolve20(projectRoot, ".variants"), { recursive: true });
   try {
     await gitExec(["worktree", "add", "-b", variantName, variantDir], { cwd: projectRoot });
   } catch (e) {
@@ -6397,7 +6623,7 @@ var app25 = new Hono25().get("/:name/variants", async (c) => {
     return c.json({ error: `npm install failed: ${msg}` }, 500);
   }
   if (body.soul) {
-    writeFileSync9(resolve20(variantDir, "home/SOUL.md"), body.soul);
+    writeFileSync10(resolve20(variantDir, "home/SOUL.md"), body.soul);
   }
   const variantPort = body.port ?? await nextPort();
   await addVariant(variantName, mindName, variantPort, variantDir, variantName);
@@ -6432,7 +6658,7 @@ var app25 = new Hono25().get("/:name/variants", async (c) => {
   } catch {
   }
   const projectRoot = mindDir(mindName);
-  if (existsSync15(variantEntry.dir)) {
+  if (existsSync16(variantEntry.dir)) {
     const status = (await gitExec(["status", "--porcelain"], { cwd: variantEntry.dir })).trim();
     if (status) {
       try {
@@ -6440,7 +6666,7 @@ var app25 = new Hono25().get("/:name/variants", async (c) => {
         await gitExec(["commit", "-m", "Auto-commit uncommitted changes before merge"], {
           cwd: variantEntry.dir
         });
-      } catch (e) {
+      } catch (_e) {
         return c.json(
           {
             error: "Failed to auto-commit variant changes. Commit or stash manually before merging."
@@ -6477,7 +6703,7 @@ var app25 = new Hono25().get("/:name/variants", async (c) => {
       await gitExec(["commit", "-m", "Auto-commit uncommitted changes before merge"], {
         cwd: projectRoot
       });
-    } catch (e) {
+    } catch (_e) {
       return c.json(
         { error: "Failed to auto-commit main changes. Commit or stash manually before merging." },
         500
@@ -6486,14 +6712,14 @@ var app25 = new Hono25().get("/:name/variants", async (c) => {
   }
   try {
     await gitExec(["merge", variantEntry.branch], { cwd: projectRoot });
-  } catch (e) {
+  } catch (_e) {
     return c.json({ error: "Merge failed. Resolve conflicts manually." }, 500);
   }
   await cleanupVariant(variantName, projectRoot, variantEntry.dir);
   if (variantName.endsWith("-upgrade") || variantName === "upgrade") {
     try {
-      const { computeTemplateHash: computeTemplateHash2 } = await import("./template-hash-BIMA4ILT.js");
-      const { setMindTemplateHash: setMindTemplateHash2 } = await import("./registry-NDNOOYG4.js");
+      const { computeTemplateHash: computeTemplateHash2 } = await import("./template-hash-3HOR4UAJ.js");
+      const { setMindTemplateHash: setMindTemplateHash2 } = await import("./registry-ODSALQQL.js");
       const tmpl = parentEntry.template ?? "claude";
       await setMindTemplateHash2(mindName, computeTemplateHash2(tmpl));
     } catch (err) {
@@ -6548,19 +6774,19 @@ var app25 = new Hono25().get("/:name/variants", async (c) => {
   await cleanupVariant(variantName, projectRoot, variantEntry.dir, { stop: true });
   return c.json({ ok: true });
 });
-var variants_default = app25;
+var variants_default = app24;
 
 // src/web/api/volute/channels.ts
-import { zValidator as zValidator11 } from "@hono/zod-validator";
-import { Hono as Hono26 } from "hono";
-import { z as z11 } from "zod";
-var createSchema3 = z11.object({
-  name: z11.string().min(1).max(50).regex(/^[a-z0-9][a-z0-9-]*$/, "Channel names must be lowercase alphanumeric with hyphens")
+import { zValidator as zValidator10 } from "@hono/zod-validator";
+import { Hono as Hono25 } from "hono";
+import { z as z10 } from "zod";
+var createSchema2 = z10.object({
+  name: z10.string().min(1).max(50).regex(/^[a-z0-9][a-z0-9-]*$/, "Channel names must be lowercase alphanumeric with hyphens")
 });
-var inviteSchema = z11.object({
-  username: z11.string().min(1)
+var inviteSchema = z10.object({
+  username: z10.string().min(1)
 });
-var app26 = new Hono26().get("/", async (c) => {
+var app25 = new Hono25().get("/", async (c) => {
   const user = c.get("user");
   const channels = await listChannels();
   const results = await Promise.all(
@@ -6571,7 +6797,7 @@ var app26 = new Hono26().get("/", async (c) => {
     })
   );
   return c.json(results);
-}).post("/", zValidator11("json", createSchema3), async (c) => {
+}).post("/", zValidator10("json", createSchema2), async (c) => {
   const user = c.get("user");
   const body = c.req.valid("json");
   try {
@@ -6604,7 +6830,7 @@ var app26 = new Hono26().get("/", async (c) => {
   if (!ch) return c.json({ error: "Channel not found" }, 404);
   const participants = await getParticipants(ch.id);
   return c.json(participants);
-}).post("/:name/invite", zValidator11("json", inviteSchema), async (c) => {
+}).post("/:name/invite", zValidator10("json", inviteSchema), async (c) => {
   const name = c.req.param("name");
   const inviter = c.get("user");
   const { username } = c.req.valid("json");
@@ -6624,13 +6850,13 @@ var app26 = new Hono26().get("/", async (c) => {
   ]);
   return c.json({ ok: true });
 });
-var channels_default2 = app26;
+var channels_default2 = app25;
 
 // src/web/api/volute/chat.ts
-import { zValidator as zValidator12 } from "@hono/zod-validator";
-import { Hono as Hono27 } from "hono";
+import { zValidator as zValidator11 } from "@hono/zod-validator";
+import { Hono as Hono26 } from "hono";
 import { streamSSE as streamSSE6 } from "hono/streaming";
-import { z as z12 } from "zod";
+import { z as z11 } from "zod";
 
 // src/lib/bridge-outbound.ts
 function extractContent(contentBlocks) {
@@ -6710,8 +6936,8 @@ async function fanOutToMinds2(opts) {
   const participantNames = participants.map((p) => p.username);
   const isDM = opts.isDM ?? participants.length === 2;
   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 { getMindManager: getMindManager2 } = await import("./mind-manager-YFCOIAAX.js");
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-O7YQFCV5.js");
   const manager = getMindManager2();
   const sm = getSleepManagerIfReady2();
   const targetMinds = mindParticipants.map((ap) => {
@@ -6760,24 +6986,24 @@ async function fanOutToMinds2(opts) {
     });
   }
 }
-var fileSchema = z12.object({
-  filename: z12.string(),
-  data: z12.string()
+var fileSchema = z11.object({
+  filename: z11.string(),
+  data: z11.string()
   // base64
 });
-var chatSchema = z12.object({
-  message: z12.string().optional(),
-  conversationId: z12.string().optional(),
-  sender: z12.string().optional(),
-  images: z12.array(
-    z12.object({
-      media_type: z12.string(),
-      data: z12.string()
+var chatSchema = z11.object({
+  message: z11.string().optional(),
+  conversationId: z11.string().optional(),
+  sender: z11.string().optional(),
+  images: z11.array(
+    z11.object({
+      media_type: z11.string(),
+      data: z11.string()
     })
   ).optional(),
-  files: z12.array(fileSchema).optional()
+  files: z11.array(fileSchema).optional()
 });
-var app27 = new Hono27().post("/:name/chat", zValidator12("json", chatSchema), async (c) => {
+var app26 = new Hono26().post("/:name/chat", zValidator11("json", chatSchema), async (c) => {
   const name = c.req.param("name");
   const baseName = await getBaseName(name);
   const entry = await findMind(baseName);
@@ -6903,15 +7129,15 @@ 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(),
-  files: z12.array(fileSchema).optional()
+var unifiedChatSchema2 = z11.object({
+  message: z11.string().optional(),
+  conversationId: z11.string(),
+  images: z11.array(z11.object({ media_type: z11.string(), data: z11.string() })).optional(),
+  files: z11.array(fileSchema).optional()
 });
-var unifiedChatApp = new Hono27().post(
+var unifiedChatApp = new Hono26().post(
   "/chat",
-  zValidator12("json", unifiedChatSchema2),
+  zValidator11("json", unifiedChatSchema2),
   async (c) => {
     const user = c.get("user");
     const body = c.req.valid("json");
@@ -6986,18 +7212,18 @@ var unifiedChatApp = new Hono27().post(
     return c.json({ ok: true, conversationId: body.conversationId });
   }
 );
-var chat_default2 = app27;
+var chat_default2 = app26;
 
 // src/web/api/volute/conversations.ts
-import { zValidator as zValidator13 } from "@hono/zod-validator";
-import { Hono as Hono28 } from "hono";
-import { z as z13 } from "zod";
-var createConvSchema = z13.object({
-  title: z13.string().optional(),
-  participantIds: z13.array(z13.number()).optional(),
-  participantNames: z13.array(z13.string()).optional()
+import { zValidator as zValidator12 } from "@hono/zod-validator";
+import { Hono as Hono27 } from "hono";
+import { z as z12 } from "zod";
+var createConvSchema = z12.object({
+  title: z12.string().optional(),
+  participantIds: z12.array(z12.number()).optional(),
+  participantNames: z12.array(z12.string()).optional()
 });
-var app28 = new Hono28().get("/:name/conversations", async (c) => {
+var app27 = new Hono27().get("/:name/conversations", async (c) => {
   const name = c.req.param("name");
   const user = c.get("user");
   let lookupId = user.id;
@@ -7008,7 +7234,7 @@ var app28 = new Hono28().get("/:name/conversations", async (c) => {
   const all = await listConversationsForUser(lookupId);
   const convs = all.filter((c2) => c2.mind_name === name || c2.type === "channel");
   return c.json(convs);
-}).post("/:name/conversations", zValidator13("json", createConvSchema), async (c) => {
+}).post("/:name/conversations", zValidator12("json", createConvSchema), async (c) => {
   const name = c.req.param("name");
   const user = c.get("user");
   const body = c.req.valid("json");
@@ -7028,7 +7254,7 @@ var app28 = new Hono28().get("/:name/conversations", async (c) => {
         if (hyphenIdx > 0) {
           const prefix = pname.slice(0, hyphenIdx);
           if (["discord", "slack", "telegram"].includes(prefix)) {
-            existing = await getUserByUsername(prefix + ":" + pname.slice(hyphenIdx + 1));
+            existing = await getUserByUsername(`${prefix}:${pname.slice(hyphenIdx + 1)}`);
           }
         }
       }
@@ -7094,18 +7320,18 @@ var app28 = new Hono28().get("/:name/conversations", async (c) => {
   if (!deleted) return c.json({ error: "Conversation not found" }, 404);
   return c.json({ ok: true });
 });
-var conversations_default2 = app28;
+var conversations_default2 = app27;
 
 // src/web/api/volute/user-conversations.ts
-import { zValidator as zValidator14 } from "@hono/zod-validator";
-import { Hono as Hono29 } from "hono";
+import { zValidator as zValidator13 } from "@hono/zod-validator";
+import { Hono as Hono28 } from "hono";
 import { streamSSE as streamSSE7 } from "hono/streaming";
-import { z as z14 } from "zod";
-var createSchema4 = z14.object({
-  title: z14.string().optional(),
-  participantNames: z14.array(z14.string()).min(1)
+import { z as z13 } from "zod";
+var createSchema3 = z13.object({
+  title: z13.string().optional(),
+  participantNames: z13.array(z13.string()).min(1)
 });
-var app29 = new Hono29().use("*", authMiddleware).get("/", async (c) => {
+var app28 = new Hono28().use("*", authMiddleware).get("/", async (c) => {
   const user = c.get("user");
   const convs = await listConversationsWithParticipants(user.id);
   return c.json(convs);
@@ -7117,7 +7343,7 @@ var app29 = new Hono29().use("*", authMiddleware).get("/", async (c) => {
   }
   const msgs = await getMessages(id);
   return c.json(msgs);
-}).post("/", zValidator14("json", createSchema4), async (c) => {
+}).post("/", zValidator13("json", createSchema3), async (c) => {
   const user = c.get("user");
   const body = c.req.valid("json");
   const participantIds = /* @__PURE__ */ new Set();
@@ -7182,12 +7408,12 @@ var app29 = new Hono29().use("*", authMiddleware).get("/", async (c) => {
   if (!deleted) return c.json({ error: "Conversation not found" }, 404);
   return c.json({ ok: true });
 });
-var user_conversations_default = app29;
+var user_conversations_default = app28;
 
 // src/web/app.ts
 var httpLog = logger_default.child("http");
-var app30 = new Hono30();
-app30.onError((err, c) => {
+var app29 = new Hono29();
+app29.onError((err, c) => {
   if (err instanceof HTTPException) {
     return err.getResponse();
   }
@@ -7198,10 +7424,10 @@ app30.onError((err, c) => {
   });
   return c.json({ error: "Internal server error" }, 500);
 });
-app30.notFound((c) => {
+app29.notFound((c) => {
   return c.json({ error: "Not found" }, 404);
 });
-app30.use("*", async (c, next) => {
+app29.use("*", async (c, next) => {
   const start = Date.now();
   await next();
   const duration = Date.now() - start;
@@ -7212,7 +7438,7 @@ app30.use("*", async (c, next) => {
     httpLog.debug("request", data);
   }
 });
-app30.get("/api/health", (c) => {
+app29.get("/api/health", (c) => {
   let version = "unknown";
   let cached = null;
   try {
@@ -7227,40 +7453,44 @@ app30.get("/api/health", (c) => {
     ...cached?.updateAvailable ? { updateAvailable: true, latest: cached.latest } : {}
   });
 });
-app30.use("/api/*", bodyLimit({ maxSize: 10 * 1024 * 1024 }));
-app30.use("/api/*", csrf());
-app30.use("/api/activity/*", authMiddleware);
-app30.use("/api/minds/*", authMiddleware);
-app30.use("/api/conversations/*", authMiddleware);
-app30.use("/api/volute/*", authMiddleware);
-app30.use("/api/system/*", authMiddleware);
-app30.use("/api/env/*", authMiddleware);
-app30.use("/api/prompts/*", authMiddleware);
-app30.use("/api/skills/*", authMiddleware);
-app30.use("/api/notes/*", authMiddleware);
-app30.use("/api/bridges/*", authMiddleware);
-app30.use("/api/v1/*", authMiddleware);
-app30.route("/pages", pages_default);
-app30.route("/public", public_files_default);
-var routes = app30.route("/api/activity", activity_default).route("/api/keys", keys_default).route("/api/auth", auth_default).route("/api/system", system_default).route("/api/system", update_default).route("/api/minds", minds_default).route("/api/minds", chat_default2).route("/api/minds", schedules_default).route("/api/minds", logs_default).route("/api/minds", typing_default).route("/api/minds", variants_default).route("/api/minds", file_sharing_default).route("/api/minds", files_default).route("/api/minds", channels_default).route("/api/minds", shared_default).route("/api/minds", env_default).route("/api/minds", mind_skills_default).route("/api/minds", conversations_default2).route("/api/env", sharedEnvApp).route("/api/notes", notes_default).route("/api/prompts", prompts_default).route("/api/skills", skills_default).route("/api/conversations", user_conversations_default).route("/api/volute/channels", channels_default2).route("/api/volute", unifiedChatApp).route("/api/bridges", bridges_default).route("/api/v1/conversations", conversations_default).route("/api/v1/events", events_default).route("/api/v1", chat_default);
-app30.route("/api/v1/minds", minds_default);
-app30.route("/api/v1/minds", typing_default);
-app30.route("/api/v1/minds", variants_default);
-app30.route("/api/v1/minds", files_default);
-app30.route("/api/v1/minds", env_default);
-app30.route("/api/v1/minds", mind_skills_default);
-app30.route("/api/v1/minds", schedules_default);
-app30.route("/api/v1/minds", logs_default);
-app30.route("/api/v1/system", system_default);
-app30.route("/api/v1/system", update_default);
-app30.route("/api/v1/prompts", prompts_default);
-app30.route("/api/v1/skills", skills_default);
-app30.route("/api/v1/env", sharedEnvApp);
-app30.route("/api/v1/channels", channels_default2);
-var app_default = app30;
+app29.use("/api/*", bodyLimit({ maxSize: 10 * 1024 * 1024 }));
+app29.use("/api/*", csrf());
+app29.use("/api/activity/*", authMiddleware);
+app29.use("/api/minds/*", authMiddleware);
+app29.use("/api/conversations/*", authMiddleware);
+app29.use("/api/volute/*", authMiddleware);
+app29.use("/api/system/*", authMiddleware);
+app29.use("/api/env/*", authMiddleware);
+app29.use("/api/prompts/*", authMiddleware);
+app29.use("/api/skills/*", authMiddleware);
+app29.use("/api/extensions/*", authMiddleware);
+app29.use("/api/bridges/*", authMiddleware);
+app29.use("/api/v1/*", authMiddleware);
+app29.route("/public", public_files_default);
+var routes = app29.route("/api/activity", activity_default).route("/api/keys", keys_default).route("/api/auth", auth_default).route("/api/system", system_default).route("/api/system", update_default).route("/api/minds", minds_default).route("/api/minds", chat_default2).route("/api/minds", schedules_default).route("/api/minds", logs_default).route("/api/minds", typing_default).route("/api/minds", variants_default).route("/api/minds", file_sharing_default).route("/api/minds", files_default).route("/api/minds", channels_default).route("/api/minds", shared_default).route("/api/minds", env_default).route("/api/minds", mind_skills_default).route("/api/minds", conversations_default2).route("/api/env", sharedEnvApp).route("/api/prompts", prompts_default).route("/api/skills", skills_default).route("/api/conversations", user_conversations_default).route("/api/volute/channels", channels_default2).route("/api/volute", unifiedChatApp).route("/api/bridges", bridges_default).route("/api/extensions", extensions_default).route("/api/v1/conversations", conversations_default).route("/api/v1/events", events_default).route("/api/v1", chat_default);
+app29.route("/api/v1/minds", minds_default);
+app29.route("/api/v1/minds", typing_default);
+app29.route("/api/v1/minds", variants_default);
+app29.route("/api/v1/minds", files_default);
+app29.route("/api/v1/minds", env_default);
+app29.route("/api/v1/minds", mind_skills_default);
+app29.route("/api/v1/minds", schedules_default);
+app29.route("/api/v1/minds", logs_default);
+app29.route("/api/v1/system", system_default);
+app29.route("/api/v1/system", update_default);
+app29.route("/api/v1/prompts", prompts_default);
+app29.route("/api/v1/skills", skills_default);
+app29.route("/api/v1/env", sharedEnvApp);
+app29.route("/api/v1/channels", channels_default2);
+var app_default = app29;
 
 // src/web/server.ts
-var MIME_TYPES3 = {
+import { existsSync as existsSync17 } from "fs";
+import { readFile as readFile3, stat as stat3 } from "fs/promises";
+import { createServer as createHttpsServer } from "https";
+import { dirname as dirname2, extname as extname4, resolve as resolve21 } from "path";
+import { serve } from "@hono/node-server";
+var MIME_TYPES2 = {
   ".html": "text/html",
   ".js": "application/javascript",
   ".css": "text/css",
@@ -7278,7 +7508,7 @@ async function startServer({
   let searchDir = dirname2(new URL(import.meta.url).pathname);
   for (let i = 0; i < 5; i++) {
     const candidate = resolve21(searchDir, "dist", "web-assets");
-    if (existsSync16(candidate)) {
+    if (existsSync17(candidate)) {
       assetsDir = candidate;
       break;
     }
@@ -7287,20 +7517,20 @@ async function startServer({
   if (assetsDir) {
     app_default.get("*", async (c) => {
       const urlPath = new URL(c.req.url).pathname;
-      if (urlPath.startsWith("/api/")) return c.notFound();
+      if (urlPath.startsWith("/api/") || urlPath.startsWith("/ext/")) return c.notFound();
       const filePath = resolve21(assetsDir, urlPath.slice(1));
       if (!filePath.startsWith(assetsDir)) return c.text("Forbidden", 403);
-      const s = await stat4(filePath).catch(() => null);
+      const s = await stat3(filePath).catch(() => null);
       if (s?.isFile()) {
-        const ext = extname5(filePath);
-        const mime = MIME_TYPES3[ext] || "application/octet-stream";
-        const body = await readFile4(filePath);
+        const ext = extname4(filePath);
+        const mime = MIME_TYPES2[ext] || "application/octet-stream";
+        const body = await readFile3(filePath);
         return c.body(body, 200, { "Content-Type": mime });
       }
       const indexPath = resolve21(assetsDir, "index.html");
-      const indexStat = await stat4(indexPath).catch(() => null);
+      const indexStat = await stat3(indexPath).catch(() => null);
       if (indexStat?.isFile()) {
-        const body = await readFile4(indexPath, "utf-8");
+        const body = await readFile3(indexPath, "utf-8");
         return c.html(body);
       }
       return c.text("Not found", 404);
@@ -7377,7 +7607,7 @@ async function startDaemon(opts) {
   }
   const DAEMON_PID_PATH = resolve22(systemDir, "daemon.pid");
   const DAEMON_JSON_PATH = resolve22(systemDir, "daemon.json");
-  mkdirSync11(home, { recursive: true });
+  mkdirSync12(home, { recursive: true });
   ensureSystemDir();
   migrateToSystemDir();
   migrateAgentsToMinds();
@@ -7386,33 +7616,38 @@ async function startDaemon(opts) {
   } catch (err) {
     logger_default.warn("failed to initialize shared repo", logger_default.errorData(err));
   }
-  await (await import("./db-IC4J52XQ.js")).getDb();
-  const { migrateRegistryToDb } = await import("./migrate-registry-to-db-XC7T5B7P.js");
+  await (await import("./db-HMFPIRO2.js")).getDb();
+  const { migrateRegistryToDb } = await import("./migrate-registry-to-db-FK35IPEH.js");
   migrateRegistryToDb();
   try {
-    const { migrateGroupDMsToChannels } = await import("./conversations-P5BL7RMX.js");
+    const { migrateGroupDMsToChannels } = await import("./conversations-7KVQV7EZ.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");
+  const { initSandbox } = await import("./sandbox-O5FUSF43.js");
   await initSandbox();
   try {
     await syncBuiltinSkills();
   } catch (err) {
     logger_default.error("failed to sync built-in skills", logger_default.errorData(err));
   }
+  try {
+    await loadAllExtensions(app_default, authMiddleware);
+    notifyExtensionsDaemonStart();
+  } catch (err) {
+    logger_default.error("failed to load extensions", logger_default.errorData(err));
+  }
+  await initDefaultSkills();
   try {
     await ensureSystemChannel();
   } catch (err) {
     logger_default.warn("failed to ensure #system channel", logger_default.errorData(err));
   }
-  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");
+    const { getTailscaleTls } = await import("./tailscale-BM72RXCJ.js");
     const tlsConfig = await getTailscaleTls();
     tls = { key: tlsConfig.key, cert: tlsConfig.cert };
     logger_default.info("Tailscale HTTPS enabled", { hostname: tlsConfig.hostname });
@@ -7433,11 +7668,11 @@ async function startDaemon(opts) {
   process.env.VOLUTE_DAEMON_TOKEN = token;
   process.env.VOLUTE_DAEMON_PORT = String(daemonPort);
   process.env.VOLUTE_DAEMON_HOSTNAME = hostname;
-  writeFileSync10(DAEMON_PID_PATH, myPid, { mode: 420 });
+  writeFileSync11(DAEMON_PID_PATH, myPid, { mode: 420 });
   const daemonConfig = { port, hostname, token };
   if (internalPort) daemonConfig.internalPort = internalPort;
   if (tls) daemonConfig.tls = true;
-  writeFileSync10(DAEMON_JSON_PATH, `${JSON.stringify(daemonConfig, null, 2)}
+  writeFileSync11(DAEMON_JSON_PATH, `${JSON.stringify(daemonConfig, null, 2)}
 `, { mode: 420 });
   const delivery = initDeliveryManager();
   const manager = initMindManager();
@@ -7493,7 +7728,7 @@ async function startDaemon(opts) {
   bridgeManager.startBridges(daemonPort).catch((err) => {
     logger_default.warn("failed to start bridges", logger_default.errorData(err));
   });
-  import("./cloud-sync-KILFGV5Q.js").then(
+  import("./cloud-sync-JV4LJOK3.js").then(
     ({ consumeQueuedMessages }) => consumeQueuedMessages().catch((err) => {
       logger_default.warn("failed to consume queued cloud messages", logger_default.errorData(err));
     })
@@ -7501,7 +7736,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-WDHRO3XD.js");
+    const { backfillTemplateHashes, notifyVersionUpdate } = await import("./version-notify-2NTWVEHL.js");
     backfillTemplateHashes();
     notifyVersionUpdate().catch((err) => {
       logger_default.warn("failed to send version update notifications", logger_default.errorData(err));
@@ -7524,13 +7759,13 @@ async function startDaemon(opts) {
   logger_default.info(`running on ${hostname}:${port}, pid ${myPid}`);
   function cleanup() {
     try {
-      if (readFileSync13(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
+      if (readFileSync14(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
         unlinkSync2(DAEMON_PID_PATH);
       }
     } catch {
     }
     try {
-      const data = JSON.parse(readFileSync13(DAEMON_JSON_PATH, "utf-8"));
+      const data = JSON.parse(readFileSync14(DAEMON_JSON_PATH, "utf-8"));
       if (data.token === token) {
         unlinkSync2(DAEMON_JSON_PATH);
       }
@@ -7552,7 +7787,7 @@ async function startDaemon(opts) {
       }
     };
     try {
-      safe("stopAllWatchers", stopAllWatchers);
+      safe("notifyExtensionsDaemonStop", notifyExtensionsDaemonStop);
       safe("stopAllActivityTrackers", stopAll);
       safe("unsubscribeWebhook", unsubscribeWebhook);
       safe("sleepManager.stop", () => sleepManager.stop());