volute 0.20.0 → 0.21.0

package/dist/daemon.js

@@ -1,20 +1,4 @@
 #!/usr/bin/env node
-import {
-  SEED_SKILLS,
-  STANDARD_SKILLS,
-  getSharedSkill,
-  importSkillFromDir,
-  installSkill,
-  listFilesRecursive,
-  listMindSkills,
-  listSharedSkills,
-  publishSkill,
-  removeSharedSkill,
-  sharedSkillsDir,
-  syncBuiltinSkills,
-  uninstallSkill,
-  updateSkill
-} from "./chunk-IKMY5X76.js";
 import {
   addSharedWorktree,
   ensureSharedRepo,
@@ -23,16 +7,10 @@ import {
   sharedMerge,
   sharedPull,
   sharedStatus
-} from "./chunk-TIWH32HP.js";
+} from "./chunk-L3LHXZD7.js";
 import {
   readSystemsConfig
-} from "./chunk-FCDU5BFX.js";
-import {
-  getActiveMinds,
-  markIdle,
-  onMindEvent,
-  stopAll
-} from "./chunk-GZ7DW4YL.js";
+} from "./chunk-HFCBO2GL.js";
 import {
   PROMPT_DEFAULTS,
   PROMPT_KEYS,
@@ -47,7 +25,7 @@ import {
   loadJsonMap,
   saveJsonMap,
   substitute
-} from "./chunk-PUVXOZ6T.js";
+} from "./chunk-7LPTHFIL.js";
 import {
   deliverMessage,
   extractTextContent,
@@ -57,20 +35,26 @@ import {
   publish,
   publishTypingForChannels,
   subscribe
-} from "./chunk-FGSYHIS3.js";
+} from "./chunk-OGZYB5GL.js";
+import {
+  applyInitFiles,
+  composeTemplate,
+  computeTemplateHash,
+  copyTemplateToDir,
+  findTemplatesRoot,
+  listFiles
+} from "./chunk-AKPFNL7L.js";
+import {
+  getActiveMinds,
+  markIdle,
+  onMindEvent,
+  stopAll
+} from "./chunk-HGCDWKSP.js";
 import {
   broadcast,
   publish as publish2,
   subscribe as subscribe2
-} from "./chunk-UU7A7KLB.js";
-import {
-  logBuffer,
-  logger_default
-} from "./chunk-YUIHSKR6.js";
-import {
-  CHANNELS,
-  getChannelDriver
-} from "./chunk-UJ6GHNR7.js";
+} from "./chunk-A4S7H6G6.js";
 import {
   findOpenClawSession,
   importOpenClawConnectors,
@@ -78,33 +62,54 @@ import {
   parseNameFromIdentity,
   readVoluteConfig,
   writeVoluteConfig
-} from "./chunk-O6ASDHFO.js";
+} from "./chunk-PC6R6UUW.js";
 import {
   loadMergedEnv,
   mindEnvPath,
   readEnv,
   sharedEnvPath,
   writeEnv
-} from "./chunk-VDWCHYTS.js";
+} from "./chunk-PHU4DEAJ.js";
+import {
+  isHomeOnlyArchive
+} from "./chunk-KTJGZ7M7.js";
 import {
-  getDb
-} from "./chunk-5XNT2472.js";
+  SEED_SKILLS,
+  STANDARD_SKILLS,
+  getSharedSkill,
+  importSkillFromDir,
+  installSkill,
+  listFilesRecursive,
+  listMindSkills,
+  listSharedSkills,
+  publishSkill,
+  removeSharedSkill,
+  sharedSkillsDir,
+  syncBuiltinSkills,
+  uninstallSkill,
+  updateSkill
+} from "./chunk-5462YKWP.js";
 import {
   activity,
   conversationParticipants,
   conversations,
+  getDb,
   messages,
   mindHistory,
   sessions,
   systemPrompts,
   users
-} from "./chunk-NSE7VJQA.js";
+} from "./chunk-SGPEZ32F.js";
+import {
+  logBuffer,
+  logger_default
+} from "./chunk-YUIHSKR6.js";
 import "./chunk-D424ZQGI.js";
 import {
   exec,
   gitExec,
   resolveVoluteBin
-} from "./chunk-DYZGP3EW.js";
+} from "./chunk-IPJXU366.js";
 import {
   chownMindDir,
   createMindUser,
@@ -112,16 +117,19 @@ import {
   ensureVoluteGroup,
   isIsolationEnabled,
   wrapForIsolation
-} from "./chunk-OGXOMR65.js";
+} from "./chunk-NWPT4ASZ.js";
 import {
   checkForUpdate,
   checkForUpdateCached,
   getCurrentVersion
-} from "./chunk-SCUDS4US.js";
+} from "./chunk-ON3FF5JA.js";
 import {
   buildVoluteSlug,
+  resolveChannelId,
+  slugify,
+  splitMessage,
   writeChannelEntry
-} from "./chunk-RHEGSQFJ.js";
+} from "./chunk-WSLPZF72.js";
 import {
   addMind,
   addVariant,
@@ -141,22 +149,26 @@ import {
   removeVariant,
   setMindRunning,
   setMindStage,
+  setMindTemplateHash,
   setVariantRunning,
   stateDir,
   validateBranchName,
   validateMindName,
-  voluteHome
-} from "./chunk-EBGCNDMM.js";
-import "./chunk-K3NQKI34.js";
+  voluteHome,
+  writeVariants
+} from "./chunk-B2CPS4QU.js";
+import {
+  __export
+} from "./chunk-K3NQKI34.js";
 
 // src/daemon.ts
 import { randomBytes as randomBytes2 } from "crypto";
-import { mkdirSync as mkdirSync11, readFileSync as readFileSync13, unlinkSync as unlinkSync2, writeFileSync as writeFileSync11 } from "fs";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync13, unlinkSync as unlinkSync2, writeFileSync as writeFileSync10 } from "fs";
 import { homedir as homedir2 } from "os";
 import { resolve as resolve22 } from "path";
 import { format } from "util";
 
-// src/lib/connector-manager.ts
+// src/lib/daemon/connector-manager.ts
 import { spawn } from "child_process";
 import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
 import { dirname, resolve as resolve2 } from "path";
@@ -233,7 +245,7 @@ function checkMissingEnvVars(def, env) {
   return def.envVars.filter((v) => v.required && !env[v.name]);
 }
 
-// src/lib/connector-manager.ts
+// src/lib/daemon/connector-manager.ts
 var clog = logger_default.child("connectors");
 function searchUpwards(...segments) {
   let searchDir = dirname(new URL(import.meta.url).pathname);
@@ -253,13 +265,13 @@ var ConnectorManager = class {
   async startConnectors(mindName, mindDir2, mindPort, daemonPort) {
     const config = readVoluteConfig(mindDir2) ?? {};
     const types = config.connectors ?? [];
-    for (const type of types) {
-      try {
-        await this.startConnector(mindName, mindDir2, mindPort, type, daemonPort);
-      } catch (err) {
-        clog.warn(`failed to start connector ${type} for ${mindName}`, logger_default.errorData(err));
-      }
-    }
+    await Promise.all(
+      types.map(
+        (type) => this.startConnector(mindName, mindDir2, mindPort, type, daemonPort).catch((err) => {
+          clog.warn(`failed to start connector ${type} for ${mindName}`, logger_default.errorData(err));
+        })
+      )
+    );
   }
   checkConnectorEnv(type, mindName, mindDir2) {
     const mindConnectorDir = resolve2(mindDir2, "connectors", type);
@@ -281,13 +293,21 @@ var ConnectorManager = class {
       await new Promise((res) => {
         existing.child.on("exit", () => res());
         try {
-          existing.child.kill("SIGTERM");
+          if (existing.child.pid) {
+            process.kill(-existing.child.pid, "SIGTERM");
+          } else {
+            existing.child.kill("SIGTERM");
+          }
         } catch {
           res();
         }
         setTimeout(() => {
           try {
-            existing.child.kill("SIGKILL");
+            if (existing.child.pid) {
+              process.kill(-existing.child.pid, "SIGKILL");
+            } else {
+              existing.child.kill("SIGKILL");
+            }
           } catch {
           }
           res();
@@ -334,6 +354,7 @@ var ConnectorManager = class {
     );
     const spawnOpts = {
       stdio: ["ignore", "pipe", "pipe"],
+      detached: true,
       env: {
         ...process.env,
         VOLUTE_MIND_PORT: String(mindPort),
@@ -400,13 +421,13 @@ var ConnectorManager = class {
     await new Promise((resolve23) => {
       tracked.child.on("exit", () => resolve23());
       try {
-        tracked.child.kill("SIGTERM");
+        process.kill(-tracked.child.pid, "SIGTERM");
       } catch {
         resolve23();
       }
       setTimeout(() => {
         try {
-          tracked.child.kill("SIGKILL");
+          process.kill(-tracked.child.pid, "SIGKILL");
         } catch {
         }
         resolve23();
@@ -461,7 +482,11 @@ var ConnectorManager = class {
     try {
       const pid = parseInt(readFileSync2(pidPath, "utf-8").trim(), 10);
       if (pid > 0) {
-        process.kill(pid, "SIGTERM");
+        try {
+          process.kill(-pid, "SIGTERM");
+        } catch {
+          process.kill(pid, "SIGTERM");
+        }
         clog.warn(`killed orphan connector ${type} (pid ${pid})`);
       }
     } catch {
@@ -490,7 +515,7 @@ function getConnectorManager() {
   return instance;
 }
 
-// src/lib/mail-poller.ts
+// src/lib/daemon/mail-poller.ts
 var mlog = logger_default.child("mail");
 function formatEmailContent(email) {
   if (email.body) {
@@ -516,13 +541,14 @@ var MailPoller = class {
   reconnectDelay = INITIAL_RECONNECT_MS;
   reconnectAttempts = 0;
   disconnectedAt = null;
+  config = null;
   start() {
     if (this.running) {
       mlog.warn("already running \u2014 ignoring duplicate start");
       return;
     }
-    const config = readSystemsConfig();
-    if (!config) {
+    this.config = readSystemsConfig();
+    if (!this.config) {
       mlog.info("no systems config \u2014 mail disabled");
       return;
     }
@@ -531,6 +557,7 @@ var MailPoller = class {
   }
   stop() {
     this.running = false;
+    this.config = null;
     if (this.pingTimer) clearInterval(this.pingTimer);
     this.pingTimer = null;
     if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
@@ -545,16 +572,16 @@ var MailPoller = class {
   }
   connect() {
     if (!this.running) return;
-    const config = readSystemsConfig();
-    if (!config) {
+    this.config = readSystemsConfig();
+    if (!this.config) {
       mlog.info("systems config removed \u2014 stopping");
       this.stop();
       return;
     }
-    const wsUrl = `${config.apiUrl.replace(/^http/, "ws")}/api/ws`;
+    const wsUrl = `${this.config.apiUrl.replace(/^http/, "ws")}/api/ws`;
     try {
       this.ws = new WebSocket(wsUrl, {
-        headers: { Authorization: `Bearer ${config.apiKey}` }
+        headers: { Authorization: `Bearer ${this.config.apiKey}` }
       });
     } catch (err) {
       mlog.warn("failed to create WebSocket", logger_default.errorData(err));
@@ -620,11 +647,10 @@ var MailPoller = class {
   }
   /** Fetch emails that arrived while disconnected */
   catchUp(since) {
-    const config = readSystemsConfig();
-    if (!config) return;
-    const url = `${config.apiUrl}/api/mail/system/poll?since=${encodeURIComponent(since)}`;
+    if (!this.config) return;
+    const url = `${this.config.apiUrl}/api/mail/system/poll?since=${encodeURIComponent(since)}`;
     fetch(url, {
-      headers: { Authorization: `Bearer ${config.apiKey}` }
+      headers: { Authorization: `Bearer ${this.config.apiKey}` }
     }).then(async (res) => {
       if (!res.ok) {
         mlog.warn(`catch-up poll failed: HTTP ${res.status}`);
@@ -659,14 +685,13 @@ var MailPoller = class {
     });
   }
   async fetchAndDeliver(mind, notification) {
-    const config = readSystemsConfig();
-    if (!config) {
+    if (!this.config) {
       mlog.warn(`systems config missing \u2014 cannot fetch email ${notification.id} for ${mind}`);
       return;
     }
-    const url = `${config.apiUrl}/api/mail/emails/${encodeURIComponent(mind)}/${encodeURIComponent(notification.id)}`;
+    const url = `${this.config.apiUrl}/api/mail/emails/${encodeURIComponent(mind)}/${encodeURIComponent(notification.id)}`;
     const res = await fetch(url, {
-      headers: { Authorization: `Bearer ${config.apiKey}` }
+      headers: { Authorization: `Bearer ${this.config.apiKey}` }
     });
     if (!res.ok) {
       mlog.warn(`failed to fetch email ${notification.id}: HTTP ${res.status}`);
@@ -727,182 +752,9 @@ async function ensureMailAddress(mindName) {
   }
 }
 
-// src/lib/migrate-agents-to-minds.ts
-import { execFileSync } from "child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync3, renameSync, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve3 } from "path";
-var TAG = "[migrate]";
-function log(msg) {
-  console.error(`${TAG} ${msg}`);
-}
-function migrateAgentsToMinds() {
-  const home = voluteHome();
-  bridgeEnvVar();
-  const names = migrateRegistry(home);
-  migrateMindsDirectory(home);
-  migrateLogFiles(home, names);
-  migrateLinuxUsers(names);
-  migrateProfileScript();
-}
-function bridgeEnvVar() {
-  if (process.env.VOLUTE_AGENTS_DIR && !process.env.VOLUTE_MINDS_DIR) {
-    process.env.VOLUTE_MINDS_DIR = process.env.VOLUTE_AGENTS_DIR;
-    log(`bridged VOLUTE_AGENTS_DIR=${process.env.VOLUTE_AGENTS_DIR} \u2192 VOLUTE_MINDS_DIR`);
-  }
-}
-function migrateRegistry(home) {
-  const oldPath = resolve3(home, "agents.json");
-  const newPath = resolve3(home, "minds.json");
-  if (!existsSync3(oldPath) || existsSync3(newPath)) {
-    return readNamesFromRegistry(newPath);
-  }
-  const raw = readFileSync3(oldPath, "utf-8");
-  const entries = JSON.parse(raw);
-  for (const entry of entries) {
-    if (entry.stage === "mind") {
-      entry.stage = "sprouted";
-    }
-  }
-  writeFileSync2(newPath, `${JSON.stringify(entries, null, 2)}
-`);
-  try {
-    renameSync(oldPath, `${oldPath}.bak`);
-  } catch {
-  }
-  log("renamed agents.json \u2192 minds.json");
-  return entries.map((e) => e.name);
-}
-function readNamesFromRegistry(path) {
-  if (!existsSync3(path)) return [];
-  try {
-    const entries = JSON.parse(readFileSync3(path, "utf-8"));
-    return entries.map((e) => e.name);
-  } catch {
-    return [];
-  }
-}
-function migrateMindsDirectory(home) {
-  if (process.env.VOLUTE_MINDS_DIR) return;
-  const oldDir = resolve3(home, "agents");
-  const newDir = resolve3(home, "minds");
-  if (existsSync3(oldDir) && !existsSync3(newDir)) {
-    try {
-      renameSync(oldDir, newDir);
-      log("renamed agents/ \u2192 minds/");
-    } catch (err) {
-      log(`failed to rename agents/ \u2192 minds/: ${err}`);
-    }
-  }
-}
-function migrateLogFiles(home, names) {
-  for (const name of names) {
-    const logsDir = resolve3(home, "state", name, "logs");
-    const oldLog = resolve3(logsDir, "agent.log");
-    const newLog = resolve3(logsDir, "mind.log");
-    if (existsSync3(oldLog) && !existsSync3(newLog)) {
-      try {
-        renameSync(oldLog, newLog);
-        log(`renamed ${name} agent.log \u2192 mind.log`);
-      } catch (err) {
-        log(`failed to rename ${name} log file: ${err}`);
-      }
-    }
-  }
-}
-function migrateLinuxUsers(names) {
-  if (process.env.VOLUTE_ISOLATION !== "user") return;
-  const oldPrefix = "agent-";
-  const newPrefix = process.env.VOLUTE_USER_PREFIX ?? "mind-";
-  if (newPrefix !== "mind-") return;
-  for (const name of names) {
-    const oldUser = `${oldPrefix}${name}`;
-    const newUser = `${newPrefix}${name}`;
-    try {
-      execFileSync("id", [oldUser], { stdio: "ignore" });
-    } catch {
-      continue;
-    }
-    try {
-      execFileSync("id", [newUser], { stdio: "ignore" });
-      continue;
-    } catch {
-    }
-    try {
-      execFileSync("usermod", ["-l", newUser, oldUser], {
-        stdio: ["ignore", "ignore", "pipe"]
-      });
-      log(`renamed user ${oldUser} \u2192 ${newUser}`);
-    } catch (err) {
-      const stderr = err?.stderr?.toString().trim();
-      log(`failed to rename user ${oldUser}: ${stderr || err}`);
-      continue;
-    }
-    try {
-      execFileSync("getent", ["group", oldUser], { stdio: "ignore" });
-      execFileSync("groupmod", ["-n", newUser, oldUser], {
-        stdio: ["ignore", "ignore", "pipe"]
-      });
-      log(`renamed group ${oldUser} \u2192 ${newUser}`);
-    } catch {
-    }
-  }
-}
-function migrateProfileScript() {
-  const profilePath = "/etc/profile.d/volute.sh";
-  if (!existsSync3(profilePath)) return;
-  try {
-    const content = readFileSync3(profilePath, "utf-8");
-    if (!content.includes("VOLUTE_AGENTS_DIR")) return;
-    const updated = content.replace(/VOLUTE_AGENTS_DIR/g, "VOLUTE_MINDS_DIR");
-    writeFileSync2(profilePath, updated);
-    log("updated /etc/profile.d/volute.sh: VOLUTE_AGENTS_DIR \u2192 VOLUTE_MINDS_DIR");
-  } catch (err) {
-    log(`failed to update profile script: ${err}`);
-  }
-}
-
-// src/lib/migrate-state.ts
-import { copyFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readdirSync, renameSync as renameSync2 } from "fs";
-import { resolve as resolve4 } from "path";
-function migrateDotVoluteDir(name) {
-  const dir = mindDir(name);
-  const oldDir = resolve4(dir, ".volute");
-  const newDir = resolve4(dir, ".mind");
-  if (existsSync4(oldDir) && !existsSync4(newDir)) {
-    renameSync2(oldDir, newDir);
-  } else if (existsSync4(oldDir) && existsSync4(newDir)) {
-    console.warn(`[migrate] both .volute/ and .mind/ exist for ${name}, skipping rename`);
-  }
-}
-function migrateMindState(name) {
-  const src = resolve4(mindDir(name), ".mind");
-  if (!existsSync4(src)) return;
-  const dest = stateDir(name);
-  mkdirSync2(dest, { recursive: true });
-  for (const file of ["env.json", "channels.json"]) {
-    const srcPath = resolve4(src, file);
-    const destPath = resolve4(dest, file);
-    if (existsSync4(srcPath) && !existsSync4(destPath)) {
-      copyFileSync(srcPath, destPath);
-    }
-  }
-  const srcLogs = resolve4(src, "logs");
-  const destLogs = resolve4(dest, "logs");
-  if (existsSync4(srcLogs) && !existsSync4(destLogs)) {
-    mkdirSync2(destLogs, { recursive: true });
-    for (const file of readdirSync(srcLogs)) {
-      try {
-        copyFileSync(resolve4(srcLogs, file), resolve4(destLogs, file));
-      } catch (err) {
-        console.error(`[migrate] failed to copy log ${file} for ${name}:`, err);
-      }
-    }
-  }
-}
-
 // src/lib/pages-watcher.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2, statSync, watch } from "fs";
-import { join, resolve as resolve5 } from "path";
+import { existsSync as existsSync3, readdirSync, statSync, watch } from "fs";
+import { join, resolve as resolve3 } from "path";
 var watchers = /* @__PURE__ */ new Map();
 var homeWatchers = /* @__PURE__ */ new Map();
 var debounceTimers = /* @__PURE__ */ new Map();
@@ -938,18 +790,18 @@ function startPagesWatcher(mindName, pagesDir) {
 }
 function startWatcher(mindName) {
   if (watchers.has(mindName)) return;
-  const pagesDir = resolve5(mindDir(mindName), "home", "pages");
-  if (existsSync5(pagesDir)) {
+  const pagesDir = resolve3(mindDir(mindName), "home", "pages");
+  if (existsSync3(pagesDir)) {
     startPagesWatcher(mindName, pagesDir);
     return;
   }
   if (homeWatchers.has(mindName)) return;
-  const homeDir = resolve5(mindDir(mindName), "home");
-  if (!existsSync5(homeDir)) return;
+  const homeDir = resolve3(mindDir(mindName), "home");
+  if (!existsSync3(homeDir)) return;
   try {
     const hw = watch(homeDir, (_eventType, filename) => {
       if (filename !== "pages") return;
-      if (!existsSync5(pagesDir)) return;
+      if (!existsSync3(pagesDir)) return;
       hw.close();
       homeWatchers.delete(mindName);
       invalidateCache();
@@ -1001,13 +853,13 @@ function scanPagesDir(dir, urlPrefix) {
   const pages = [];
   let items;
   try {
-    items = readdirSync2(dir);
+    items = readdirSync(dir);
   } catch {
     return pages;
   }
   for (const item of items) {
     if (item.startsWith(".")) continue;
-    const fullPath = resolve5(dir, item);
+    const fullPath = resolve3(dir, item);
     try {
       const s = statSync(fullPath);
       if (s.isFile() && item.endsWith(".html")) {
@@ -1017,8 +869,8 @@ function scanPagesDir(dir, urlPrefix) {
           url: `${urlPrefix}/${item}`
         });
       } else if (s.isDirectory()) {
-        const indexPath = resolve5(fullPath, "index.html");
-        if (existsSync5(indexPath)) {
+        const indexPath = resolve3(fullPath, "index.html");
+        if (existsSync3(indexPath)) {
           const indexStat = statSync(indexPath);
           pages.push({
             file: join(item, "index.html"),
@@ -1035,8 +887,8 @@ function scanPagesDir(dir, urlPrefix) {
 }
 function buildSites() {
   const sites = [];
-  const systemPagesDir = resolve5(voluteHome(), "shared", "pages");
-  if (existsSync5(systemPagesDir)) {
+  const systemPagesDir = resolve3(voluteHome(), "shared", "pages");
+  if (existsSync3(systemPagesDir)) {
     const systemPages = scanPagesDir(systemPagesDir, "/pages/_system");
     if (systemPages.length > 0) {
       sites.push({ name: "_system", label: "System", pages: systemPages });
@@ -1044,8 +896,8 @@ function buildSites() {
   }
   const entries = readRegistry();
   for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
-    const pagesDir = resolve5(mindDir(entry.name), "home", "pages");
-    if (!existsSync5(pagesDir)) continue;
+    const pagesDir = resolve3(mindDir(entry.name), "home", "pages");
+    if (!existsSync3(pagesDir)) continue;
     const mindPages = scanPagesDir(pagesDir, `/pages/${entry.name}`);
     if (mindPages.length > 0) {
       sites.push({ name: entry.name, label: entry.name, pages: mindPages });
@@ -1057,17 +909,17 @@ function buildRecentPages() {
   const entries = readRegistry();
   const pages = [];
   for (const entry of entries) {
-    const pagesDir = resolve5(mindDir(entry.name), "home", "pages");
-    if (!existsSync5(pagesDir)) continue;
+    const pagesDir = resolve3(mindDir(entry.name), "home", "pages");
+    if (!existsSync3(pagesDir)) continue;
     let items;
     try {
-      items = readdirSync2(pagesDir);
+      items = readdirSync(pagesDir);
     } catch {
       continue;
     }
     for (const item of items) {
       if (item.startsWith(".")) continue;
-      const fullPath = resolve5(pagesDir, item);
+      const fullPath = resolve3(pagesDir, item);
       try {
         const s = statSync(fullPath);
         if (s.isFile() && item.endsWith(".html")) {
@@ -1078,8 +930,8 @@ function buildRecentPages() {
             url: `/pages/${entry.name}/${item}`
           });
         } else if (s.isDirectory()) {
-          const indexPath = resolve5(fullPath, "index.html");
-          if (existsSync5(indexPath)) {
+          const indexPath = resolve3(fullPath, "index.html");
+          if (existsSync3(indexPath)) {
             const indexStat = statSync(indexPath);
             pages.push({
               mind: entry.name,
@@ -1105,8 +957,8 @@ function getCachedRecentPages() {
   return recentPagesCache;
 }
 
-// src/lib/scheduler.ts
-import { resolve as resolve6 } from "path";
+// src/lib/daemon/scheduler.ts
+import { resolve as resolve4 } from "path";
 import { CronExpressionParser } from "cron-parser";
 var slog = logger_default.child("scheduler");
 var Scheduler = class {
@@ -1115,7 +967,7 @@ var Scheduler = class {
   lastFired = /* @__PURE__ */ new Map();
   // "mind:scheduleId" → epoch minute
   get statePath() {
-    return resolve6(voluteHome(), "scheduler-state.json");
+    return resolve4(voluteHome(), "scheduler-state.json");
   }
   start() {
     this.loadState();
@@ -1149,39 +1001,46 @@ var Scheduler = class {
   }
   tick() {
     const now = /* @__PURE__ */ new Date();
+    const epochMinute = Math.floor(now.getTime() / 6e4);
+    const cronCache = /* @__PURE__ */ new Map();
+    let anyFired = false;
     for (const [mind, schedules] of this.schedules) {
       for (const schedule of schedules) {
         if (!schedule.enabled) continue;
-        if (this.shouldFire(schedule, now, mind)) {
+        if (this.shouldFire(schedule, epochMinute, mind, cronCache)) {
+          anyFired = true;
           this.fire(mind, schedule);
         }
       }
     }
+    if (anyFired) this.saveState();
   }
-  shouldFire(schedule, now, mind) {
-    try {
-      const interval = CronExpressionParser.parse(schedule.cron);
-      const prev = interval.prev().toDate();
-      const epochMinute = Math.floor(now.getTime() / 6e4);
-      const key = `${mind}:${schedule.id}`;
-      if (this.lastFired.get(key) === epochMinute) return false;
-      const prevMinute = Math.floor(prev.getTime() / 6e4);
-      if (prevMinute === epochMinute) {
-        this.lastFired.set(key, epochMinute);
-        this.saveState();
-        return true;
+  shouldFire(schedule, epochMinute, mind, cronCache) {
+    const key = `${mind}:${schedule.id}`;
+    if (this.lastFired.get(key) === epochMinute) return false;
+    let prevMinute = cronCache.get(schedule.cron);
+    if (prevMinute === void 0) {
+      try {
+        const interval = CronExpressionParser.parse(schedule.cron);
+        const prev = interval.prev().toDate();
+        prevMinute = Math.floor(prev.getTime() / 6e4);
+        cronCache.set(schedule.cron, prevMinute);
+      } catch (err) {
+        slog.warn(`invalid cron "${schedule.cron}" for ${mind}:${schedule.id}`, logger_default.errorData(err));
+        return false;
       }
-      return false;
-    } catch (err) {
-      slog.warn(`invalid cron "${schedule.cron}" for ${mind}:${schedule.id}`, logger_default.errorData(err));
-      return false;
     }
+    if (prevMinute === epochMinute) {
+      this.lastFired.set(key, epochMinute);
+      return true;
+    }
+    return false;
   }
   async fire(mindName, schedule) {
     try {
       let text;
       if (schedule.script) {
-        const homeDir = resolve6(mindDir(mindName), "home");
+        const homeDir = resolve4(mindDir(mindName), "home");
         try {
           const output = await this.runScript(schedule.script, homeDir, mindName);
           if (!output.trim()) {
@@ -1229,19 +1088,21 @@ function getScheduler() {
   return instance3;
 }
 
-// src/lib/token-budget.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import { resolve as resolve7 } from "path";
+// src/lib/daemon/token-budget.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve5 } from "path";
 var tlog = logger_default.child("token-budget");
 var DEFAULT_BUDGET_PERIOD_MINUTES = 60;
 var MAX_QUEUE_SIZE = 100;
 var TokenBudget = class {
   budgets = /* @__PURE__ */ new Map();
   interval = null;
+  dirty = /* @__PURE__ */ new Set();
   start() {
     this.interval = setInterval(() => this.tick(), 6e4);
   }
   stop() {
+    this.flush();
     if (this.interval) clearInterval(this.interval);
     this.interval = null;
   }
@@ -1276,7 +1137,7 @@ var TokenBudget = class {
     const state = this.budgets.get(mind);
     if (!state) return;
     state.tokensUsed += inputTokens + outputTokens;
-    this.saveBudgetState(mind, state);
+    this.dirty.add(mind);
   }
   /** Returns current budget status. Does not mutate state — call acknowledgeWarning() after delivering a warning. */
   checkBudget(mind) {
@@ -1327,7 +1188,7 @@ var TokenBudget = class {
         state.tokensUsed = 0;
         state.periodStart = now;
         state.warningInjected = false;
-        this.saveBudgetState(mind, state);
+        this.dirty.add(mind);
         const queued = this.drain(mind);
         if (queued.length > 0) {
           this.replay(mind, queued).catch((err) => {
@@ -1336,21 +1197,30 @@ var TokenBudget = class {
         }
       }
     }
+    this.flush();
+  }
+  /** Flush all dirty budget states to disk. */
+  flush() {
+    for (const mind of this.dirty) {
+      const state = this.budgets.get(mind);
+      if (state) this.saveBudgetState(mind, state);
+    }
+    this.dirty.clear();
   }
   budgetStatePath(mind) {
-    return resolve7(stateDir(mind), "budget.json");
+    return resolve5(stateDir(mind), "budget.json");
   }
   saveBudgetState(mind, state) {
     try {
       const dir = stateDir(mind);
-      mkdirSync3(dir, { recursive: true });
+      mkdirSync2(dir, { recursive: true });
       const data = {
         periodStart: state.periodStart,
         tokensUsed: state.tokensUsed,
         warningInjected: state.warningInjected,
         queue: state.queue
       };
-      writeFileSync3(this.budgetStatePath(mind), `${JSON.stringify(data)}
+      writeFileSync2(this.budgetStatePath(mind), `${JSON.stringify(data)}
 `);
     } catch (err) {
       tlog.warn(`failed to save budget state for ${mind}`, logger_default.errorData(err));
@@ -1359,8 +1229,8 @@ var TokenBudget = class {
   loadBudgetState(mind) {
     try {
       const path = this.budgetStatePath(mind);
-      if (!existsSync6(path)) return null;
-      const data = JSON.parse(readFileSync4(path, "utf-8"));
+      if (!existsSync4(path)) return null;
+      const data = JSON.parse(readFileSync3(path, "utf-8"));
       if (typeof data.periodStart !== "number" || typeof data.tokensUsed !== "number") return null;
       return {
         periodStart: data.periodStart,
@@ -1415,7 +1285,7 @@ function getTokenBudget() {
   return instance4;
 }
 
-// src/lib/mind-service.ts
+// src/lib/daemon/mind-service.ts
 async function startMindFull(name) {
   const [baseName, variantName] = name.split("@", 2);
   await getMindManager().startMind(name);
@@ -1461,42 +1331,215 @@ async function stopMindFull(name) {
   }).catch((err) => logger_default.error("failed to publish mind_stopped activity", logger_default.errorData(err)));
 }
 
-// src/web/middleware/auth.ts
-import { timingSafeEqual } from "crypto";
-import { eq as eq2, lt } from "drizzle-orm";
-import { getCookie } from "hono/cookie";
-import { createMiddleware } from "hono/factory";
-
-// src/lib/auth.ts
-import { compareSync, hashSync } from "bcryptjs";
-import { and, count, eq } from "drizzle-orm";
-async function createUser(username, password) {
-  const db = await getDb();
-  const hash = hashSync(password, 10);
-  const [{ value }] = await db.select({ value: count() }).from(users).where(eq(users.user_type, "brain"));
-  const role = value === 0 ? "admin" : "pending";
-  const [result] = await db.insert(users).values({ username, password_hash: hash, role }).returning({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  });
-  return result;
-}
-async function verifyUser(username, password) {
-  const db = await getDb();
-  const row = await db.select().from(users).where(eq(users.username, username)).get();
-  if (!row) return null;
-  if (row.user_type === "mind") return null;
-  if (!compareSync(password, row.password_hash)) return null;
-  const { password_hash: _, ...user } = row;
-  return user;
+// src/lib/migrate-agents-to-minds.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync5, readFileSync as readFileSync4, renameSync, writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolve6 } from "path";
+var TAG = "[migrate]";
+function log(msg) {
+  console.error(`${TAG} ${msg}`);
 }
-async function getUser(id) {
-  const db = await getDb();
-  const row = await db.select({
-    id: users.id,
+function migrateAgentsToMinds() {
+  const home = voluteHome();
+  bridgeEnvVar();
+  const names = migrateRegistry(home);
+  migrateMindsDirectory(home);
+  migrateLogFiles(home, names);
+  migrateLinuxUsers(names);
+  migrateProfileScript();
+}
+function bridgeEnvVar() {
+  if (process.env.VOLUTE_AGENTS_DIR && !process.env.VOLUTE_MINDS_DIR) {
+    process.env.VOLUTE_MINDS_DIR = process.env.VOLUTE_AGENTS_DIR;
+    log(`bridged VOLUTE_AGENTS_DIR=${process.env.VOLUTE_AGENTS_DIR} \u2192 VOLUTE_MINDS_DIR`);
+  }
+}
+function migrateRegistry(home) {
+  const oldPath = resolve6(home, "agents.json");
+  const newPath = resolve6(home, "minds.json");
+  if (!existsSync5(oldPath) || existsSync5(newPath)) {
+    return readNamesFromRegistry(newPath);
+  }
+  const raw = readFileSync4(oldPath, "utf-8");
+  const entries = JSON.parse(raw);
+  for (const entry of entries) {
+    if (entry.stage === "mind") {
+      entry.stage = "sprouted";
+    }
+  }
+  writeFileSync3(newPath, `${JSON.stringify(entries, null, 2)}
+`);
+  try {
+    renameSync(oldPath, `${oldPath}.bak`);
+  } catch {
+  }
+  log("renamed agents.json \u2192 minds.json");
+  return entries.map((e) => e.name);
+}
+function readNamesFromRegistry(path) {
+  if (!existsSync5(path)) return [];
+  try {
+    const entries = JSON.parse(readFileSync4(path, "utf-8"));
+    return entries.map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+function migrateMindsDirectory(home) {
+  if (process.env.VOLUTE_MINDS_DIR) return;
+  const oldDir = resolve6(home, "agents");
+  const newDir = resolve6(home, "minds");
+  if (existsSync5(oldDir) && !existsSync5(newDir)) {
+    try {
+      renameSync(oldDir, newDir);
+      log("renamed agents/ \u2192 minds/");
+    } catch (err) {
+      log(`failed to rename agents/ \u2192 minds/: ${err}`);
+    }
+  }
+}
+function migrateLogFiles(home, names) {
+  for (const name of names) {
+    const logsDir = resolve6(home, "state", name, "logs");
+    const oldLog = resolve6(logsDir, "agent.log");
+    const newLog = resolve6(logsDir, "mind.log");
+    if (existsSync5(oldLog) && !existsSync5(newLog)) {
+      try {
+        renameSync(oldLog, newLog);
+        log(`renamed ${name} agent.log \u2192 mind.log`);
+      } catch (err) {
+        log(`failed to rename ${name} log file: ${err}`);
+      }
+    }
+  }
+}
+function migrateLinuxUsers(names) {
+  if (process.env.VOLUTE_ISOLATION !== "user") return;
+  const oldPrefix = "agent-";
+  const newPrefix = process.env.VOLUTE_USER_PREFIX ?? "mind-";
+  if (newPrefix !== "mind-") return;
+  for (const name of names) {
+    const oldUser = `${oldPrefix}${name}`;
+    const newUser = `${newPrefix}${name}`;
+    try {
+      execFileSync("id", [oldUser], { stdio: "ignore" });
+    } catch {
+      continue;
+    }
+    try {
+      execFileSync("id", [newUser], { stdio: "ignore" });
+      continue;
+    } catch {
+    }
+    try {
+      execFileSync("usermod", ["-l", newUser, oldUser], {
+        stdio: ["ignore", "ignore", "pipe"]
+      });
+      log(`renamed user ${oldUser} \u2192 ${newUser}`);
+    } catch (err) {
+      const stderr = err?.stderr?.toString().trim();
+      log(`failed to rename user ${oldUser}: ${stderr || err}`);
+      continue;
+    }
+    try {
+      execFileSync("getent", ["group", oldUser], { stdio: "ignore" });
+      execFileSync("groupmod", ["-n", newUser, oldUser], {
+        stdio: ["ignore", "ignore", "pipe"]
+      });
+      log(`renamed group ${oldUser} \u2192 ${newUser}`);
+    } catch {
+    }
+  }
+}
+function migrateProfileScript() {
+  const profilePath = "/etc/profile.d/volute.sh";
+  if (!existsSync5(profilePath)) return;
+  try {
+    const content = readFileSync4(profilePath, "utf-8");
+    if (!content.includes("VOLUTE_AGENTS_DIR")) return;
+    const updated = content.replace(/VOLUTE_AGENTS_DIR/g, "VOLUTE_MINDS_DIR");
+    writeFileSync3(profilePath, updated);
+    log("updated /etc/profile.d/volute.sh: VOLUTE_AGENTS_DIR \u2192 VOLUTE_MINDS_DIR");
+  } catch (err) {
+    log(`failed to update profile script: ${err}`);
+  }
+}
+
+// src/lib/migrate-state.ts
+import { copyFileSync, existsSync as existsSync6, mkdirSync as mkdirSync3, readdirSync as readdirSync2, renameSync as renameSync2 } from "fs";
+import { resolve as resolve7 } from "path";
+function migrateDotVoluteDir(name) {
+  const dir = mindDir(name);
+  const oldDir = resolve7(dir, ".volute");
+  const newDir = resolve7(dir, ".mind");
+  if (existsSync6(oldDir) && !existsSync6(newDir)) {
+    renameSync2(oldDir, newDir);
+  } else if (existsSync6(oldDir) && existsSync6(newDir)) {
+    console.warn(`[migrate] both .volute/ and .mind/ exist for ${name}, skipping rename`);
+  }
+}
+function migrateMindState(name) {
+  const src = resolve7(mindDir(name), ".mind");
+  if (!existsSync6(src)) return;
+  const dest = stateDir(name);
+  mkdirSync3(dest, { recursive: true });
+  for (const file of ["env.json", "channels.json"]) {
+    const srcPath = resolve7(src, file);
+    const destPath = resolve7(dest, file);
+    if (existsSync6(srcPath) && !existsSync6(destPath)) {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+  const srcLogs = resolve7(src, "logs");
+  const destLogs = resolve7(dest, "logs");
+  if (existsSync6(srcLogs) && !existsSync6(destLogs)) {
+    mkdirSync3(destLogs, { recursive: true });
+    for (const file of readdirSync2(srcLogs)) {
+      try {
+        copyFileSync(resolve7(srcLogs, file), resolve7(destLogs, file));
+      } catch (err) {
+        console.error(`[migrate] failed to copy log ${file} for ${name}:`, err);
+      }
+    }
+  }
+}
+
+// src/web/middleware/auth.ts
+import { timingSafeEqual } from "crypto";
+import { eq as eq2, lt } from "drizzle-orm";
+import { getCookie } from "hono/cookie";
+import { createMiddleware } from "hono/factory";
+
+// src/lib/auth.ts
+import { compareSync, hashSync } from "bcryptjs";
+import { and, count, eq } from "drizzle-orm";
+async function createUser(username, password) {
+  const db = await getDb();
+  const hash = hashSync(password, 10);
+  const [{ value }] = await db.select({ value: count() }).from(users).where(eq(users.user_type, "brain"));
+  const role = value === 0 ? "admin" : "pending";
+  const [result] = await db.insert(users).values({ username, password_hash: hash, role }).returning({
+    id: users.id,
+    username: users.username,
+    role: users.role,
+    user_type: users.user_type,
+    created_at: users.created_at
+  });
+  return result;
+}
+async function verifyUser(username, password) {
+  const db = await getDb();
+  const row = await db.select().from(users).where(eq(users.username, username)).get();
+  if (!row) return null;
+  if (row.user_type === "mind") return null;
+  if (!compareSync(password, row.password_hash)) return null;
+  const { password_hash: _, ...user } = row;
+  return user;
+}
+async function getUser(id) {
+  const db = await getDb();
+  const row = await db.select({
+    id: users.id,
     username: users.username,
     role: users.role,
     user_type: users.user_type,
@@ -1680,8 +1723,8 @@ var authMiddleware = createMiddleware(async (c, next) => {
 
 // src/web/server.ts
 import { existsSync as existsSync15 } from "fs";
-import { readFile as readFile3, stat as stat2 } from "fs/promises";
-import { dirname as dirname3, extname as extname2, resolve as resolve21 } from "path";
+import { readFile as readFile3, stat as stat3 } from "fs/promises";
+import { dirname as dirname2, extname as extname3, resolve as resolve21 } from "path";
 import { serve } from "@hono/node-server";
 
 // src/web/app.ts
@@ -1695,7 +1738,7 @@ import { desc as desc2 } from "drizzle-orm";
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
 
-// src/lib/conversations.ts
+// src/lib/events/conversations.ts
 import { randomUUID } from "crypto";
 import { and as and2, desc, eq as eq3, inArray, isNull, sql } from "drizzle-orm";
 async function createConversation(mindName, channel, opts) {
@@ -2067,51 +2110,710 @@ var app2 = new Hono2().post("/register", zValidator("json", credentialsSchema),
   if (existing) {
     return c.json({ error: "Username already taken" }, 409);
   }
-  const user = await createUser(username, password);
-  if (user.role === "admin") {
-    const sessionId = await createSession(user.id);
-    setCookie(c, "volute_session", sessionId, { path: "/", httpOnly: true, sameSite: "Lax" });
+  const user = await createUser(username, password);
+  if (user.role === "admin") {
+    const sessionId = await createSession(user.id);
+    setCookie(c, "volute_session", sessionId, { path: "/", httpOnly: true, sameSite: "Lax" });
+  }
+  return c.json({ id: user.id, username: user.username, role: user.role });
+}).post("/login", zValidator("json", credentialsSchema), async (c) => {
+  const { username, password } = c.req.valid("json");
+  const user = await verifyUser(username, password);
+  if (!user) {
+    return c.json({ error: "Invalid credentials" }, 401);
+  }
+  const sessionId = await createSession(user.id);
+  setCookie(c, "volute_session", sessionId, { path: "/", httpOnly: true, sameSite: "Lax" });
+  return c.json({ id: user.id, username: user.username, role: user.role });
+}).post("/logout", async (c) => {
+  const sessionId = getCookie2(c, "volute_session");
+  if (sessionId) {
+    await deleteSession(sessionId);
+    deleteCookie(c, "volute_session", { path: "/" });
+  }
+  return c.json({ ok: true });
+}).get("/me", async (c) => {
+  const sessionId = getCookie2(c, "volute_session");
+  if (!sessionId) return c.json({ error: "Not logged in" }, 401);
+  const userId = await getSessionUserId(sessionId);
+  if (userId == null) return c.json({ error: "Not logged in" }, 401);
+  const user = await getUser(userId);
+  if (!user) return c.json({ error: "Not logged in" }, 401);
+  return c.json({ id: user.id, username: user.username, role: user.role });
+}).route("/", admin).route("/", authenticated);
+var auth_default = app2;
+
+// src/web/api/channels.ts
+import { Hono as Hono3 } from "hono";
+
+// src/lib/channels/discord.ts
+var discord_exports = {};
+__export(discord_exports, {
+  createConversation: () => createConversation2,
+  listConversations: () => listConversations,
+  listUsers: () => listUsers2,
+  read: () => read,
+  send: () => send
+});
+var DISCORD_MAX_LENGTH = 2e3;
+var API_BASE = "https://discord.com/api/v10";
+function requireToken(env) {
+  const token = env.DISCORD_TOKEN;
+  if (!token) throw new Error("DISCORD_TOKEN not set");
+  return token;
+}
+async function discordGet(token, path) {
+  const res = await fetch(`${API_BASE}${path}`, {
+    headers: { Authorization: `Bot ${token}` }
+  });
+  if (!res.ok) {
+    throw new Error(`Discord API error: ${res.status} ${res.statusText}`);
+  }
+  return res.json();
+}
+async function read(env, channelSlug, limit) {
+  const token = requireToken(env);
+  const channelId = resolveChannelId2(env, channelSlug);
+  const res = await fetch(`${API_BASE}/channels/${channelId}/messages?limit=${limit}`, {
+    headers: { Authorization: `Bot ${token}` }
+  });
+  if (!res.ok) {
+    throw new Error(`Discord API error: ${res.status} ${res.statusText}`);
+  }
+  const messages2 = await res.json();
+  return messages2.reverse().map((m) => `${m.author.username}: ${m.content}`).join("\n");
+}
+async function send(env, channelSlug, message, images) {
+  const token = requireToken(env);
+  const channelId = resolveChannelId2(env, channelSlug);
+  if (images?.length) {
+    for (let i = 0; i < images.length; i++) {
+      const img = images[i];
+      const ext = img.media_type.split("/")[1] || "png";
+      const form = new FormData();
+      const content = i === 0 ? message.slice(0, DISCORD_MAX_LENGTH) : "";
+      form.append("payload_json", JSON.stringify({ content }));
+      form.append(
+        "files[0]",
+        new Blob([Buffer.from(img.data, "base64")], { type: img.media_type }),
+        `image.${ext}`
+      );
+      const res = await fetch(`${API_BASE}/channels/${channelId}/messages`, {
+        method: "POST",
+        headers: { Authorization: `Bot ${token}` },
+        body: form
+      });
+      if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        const partial = i > 0 ? ` (${i}/${images.length} images were already sent)` : "";
+        throw new Error(`Discord API error: ${res.status} ${body || res.statusText}${partial}`);
+      }
+    }
+    return;
+  }
+  const chunks = splitMessage(message, DISCORD_MAX_LENGTH);
+  for (let i = 0; i < chunks.length; i++) {
+    const res = await fetch(`${API_BASE}/channels/${channelId}/messages`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bot ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ content: chunks[i] })
+    });
+    if (!res.ok) {
+      const partial = i > 0 ? ` (${i}/${chunks.length} chunks were already sent)` : "";
+      throw new Error(`Discord API error: ${res.status} ${res.statusText}${partial}`);
+    }
+  }
+}
+async function listConversations(env) {
+  const token = requireToken(env);
+  const results = [];
+  const guilds = await discordGet(token, "/users/@me/guilds");
+  for (const guild of guilds) {
+    const channels = await discordGet(token, `/guilds/${guild.id}/channels`);
+    for (const ch of channels) {
+      if (ch.type !== 0) continue;
+      results.push({
+        id: `discord:${slugify(guild.name)}/${slugify(ch.name)}`,
+        platformId: ch.id,
+        name: `#${ch.name}`,
+        type: "channel"
+      });
+    }
+  }
+  const dms = await discordGet(token, "/users/@me/channels");
+  for (const dm of dms) {
+    const recipients = dm.recipients?.map((r) => r.username) ?? [];
+    const slug = recipients.length === 0 ? `discord:${dm.id}` : recipients.length === 1 ? `discord:@${slugify(recipients[0])}` : `discord:@${recipients.map(slugify).sort().join(",")}`;
+    results.push({
+      id: slug,
+      platformId: dm.id,
+      name: recipients.join(", ") || "DM",
+      type: dm.type === 1 ? "dm" : "group"
+    });
+  }
+  return results;
+}
+async function listUsers2(env) {
+  const token = requireToken(env);
+  const seen = /* @__PURE__ */ new Map();
+  const guilds = await discordGet(token, "/users/@me/guilds");
+  for (const guild of guilds) {
+    const members = await discordGet(token, `/guilds/${guild.id}/members?limit=1000`);
+    for (const m of members) {
+      if (!seen.has(m.user.id)) {
+        seen.set(m.user.id, {
+          id: m.user.id,
+          username: m.user.username,
+          type: m.user.bot ? "bot" : "human"
+        });
+      }
+    }
+  }
+  return [...seen.values()];
+}
+async function createConversation2(env, participants, _name) {
+  const token = requireToken(env);
+  if (participants.length !== 1) {
+    throw new Error(
+      "Discord group creation not supported via bot \u2014 use threads in an existing channel"
+    );
+  }
+  const allUsers = await listUsers2(env);
+  const target = allUsers.find((u) => u.username.toLowerCase() === participants[0].toLowerCase());
+  if (!target) {
+    throw new Error(`User not found: ${participants[0]}`);
+  }
+  const res = await fetch(`${API_BASE}/users/@me/channels`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bot ${token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ recipient_id: target.id })
+  });
+  if (!res.ok) {
+    throw new Error(`Discord API error: ${res.status} ${res.statusText}`);
+  }
+  const dm = await res.json();
+  const slug = `discord:@${slugify(participants[0])}`;
+  const mindName = env.VOLUTE_MIND;
+  if (mindName) {
+    writeChannelEntry(mindName, slug, {
+      platformId: dm.id,
+      platform: "discord",
+      name: participants[0],
+      type: "dm"
+    });
+  }
+  return slug;
+}
+
+// src/lib/channels/slack.ts
+var slack_exports = {};
+__export(slack_exports, {
+  createConversation: () => createConversation3,
+  listConversations: () => listConversations2,
+  listUsers: () => listUsers3,
+  read: () => read2,
+  send: () => send2
+});
+var SLACK_MAX_LENGTH = 4e3;
+var API_BASE2 = "https://slack.com/api";
+function requireToken2(env) {
+  const token = env.SLACK_BOT_TOKEN;
+  if (!token) throw new Error("SLACK_BOT_TOKEN not set");
+  return token;
+}
+async function slackApi(token, method, body) {
+  const res = await fetch(`${API_BASE2}/${method}`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    throw new Error(`Slack API HTTP error: ${res.status} ${res.statusText}`);
+  }
+  const data = await res.json();
+  if (!data.ok) {
+    throw new Error(`Slack API error: ${data.error}`);
+  }
+  return data;
+}
+async function read2(env, channelSlug, limit) {
+  const token = requireToken2(env);
+  const channelId = resolveChannelId2(env, channelSlug);
+  const data = await slackApi(token, "conversations.history", {
+    channel: channelId,
+    limit
+  });
+  return data.messages.reverse().map((m) => `${m.user ?? m.bot_id ?? "unknown"}: ${m.text}`).join("\n");
+}
+async function send2(env, channelSlug, message, images) {
+  const token = requireToken2(env);
+  const channelId = resolveChannelId2(env, channelSlug);
+  if (images?.length) {
+    for (const img of images) {
+      const ext = img.media_type.split("/")[1] || "png";
+      const filename = `image.${ext}`;
+      const binary = Buffer.from(img.data, "base64");
+      const uploadData = await slackApi(token, "files.getUploadURLExternal", {
+        filename,
+        length: binary.length
+      });
+      const uploadRes = await fetch(uploadData.upload_url, {
+        method: "POST",
+        body: binary
+      });
+      if (!uploadRes.ok) {
+        throw new Error(`Slack file upload failed: ${uploadRes.status} ${uploadRes.statusText}`);
+      }
+      await slackApi(token, "files.completeUploadExternal", {
+        files: [{ id: uploadData.file_id }],
+        channel_id: channelId
+      });
+    }
+    if (message) {
+      const chunks2 = splitMessage(message, SLACK_MAX_LENGTH);
+      for (const chunk of chunks2) {
+        await slackApi(token, "chat.postMessage", {
+          channel: channelId,
+          text: chunk
+        });
+      }
+    }
+    return;
+  }
+  const chunks = splitMessage(message, SLACK_MAX_LENGTH);
+  for (let i = 0; i < chunks.length; i++) {
+    try {
+      await slackApi(token, "chat.postMessage", {
+        channel: channelId,
+        text: chunks[i]
+      });
+    } catch (err) {
+      const partial = i > 0 ? ` (${i}/${chunks.length} chunks were already sent)` : "";
+      throw new Error(`${err instanceof Error ? err.message : err}${partial}`);
+    }
+  }
+}
+async function listConversations2(env) {
+  const token = requireToken2(env);
+  const authData = await slackApi(token, "auth.test", {});
+  const teamName = authData.team ?? "workspace";
+  const data = await slackApi(token, "conversations.list", {
+    types: "public_channel,private_channel,mpim,im",
+    limit: 1e3
+  });
+  const userMap = /* @__PURE__ */ new Map();
+  const imChannels = data.channels.filter((ch) => ch.is_im && ch.user);
+  if (imChannels.length > 0) {
+    const users2 = await listUsers3(env);
+    for (const u of users2) {
+      userMap.set(u.id, u.username);
+    }
+  }
+  return data.channels.map((ch) => {
+    let type = "channel";
+    if (ch.is_im) type = "dm";
+    else if (ch.is_mpim) type = "group";
+    let slug;
+    let name;
+    if (ch.is_im && ch.user) {
+      const username = userMap.get(ch.user) ?? ch.user;
+      slug = `slack:@${slugify(username)}`;
+      name = username;
+    } else if (ch.name) {
+      slug = `slack:${slugify(teamName)}/${slugify(ch.name)}`;
+      name = ch.name;
+    } else {
+      slug = `slack:${ch.id}`;
+      name = ch.id;
+    }
+    return {
+      id: slug,
+      platformId: ch.id,
+      name,
+      type,
+      participantCount: ch.num_members
+    };
+  });
+}
+async function listUsers3(env) {
+  const token = requireToken2(env);
+  const data = await slackApi(token, "users.list", {});
+  return data.members.filter((m) => !m.deleted).map((m) => ({
+    id: m.id,
+    username: m.name,
+    type: m.is_bot ? "bot" : "human"
+  }));
+}
+async function createConversation3(env, participants, name) {
+  const token = requireToken2(env);
+  const allUsers = await listUsers3(env);
+  const ids = [];
+  for (const p of participants) {
+    const user = allUsers.find((u) => u.username.toLowerCase() === p.toLowerCase());
+    if (!user) throw new Error(`User not found: ${p}`);
+    ids.push(user.id);
+  }
+  const mindName = env.VOLUTE_MIND;
+  if (name) {
+    const createData = await slackApi(token, "conversations.create", {
+      name,
+      is_private: true
+    });
+    const channelId = createData.channel.id;
+    for (const userId of ids) {
+      await slackApi(token, "conversations.invite", {
+        channel: channelId,
+        users: userId
+      });
+    }
+    const authData = await slackApi(token, "auth.test", {});
+    const teamName = authData.team ?? "workspace";
+    const slug2 = `slack:${slugify(teamName)}/${slugify(name)}`;
+    if (mindName) {
+      writeChannelEntry(mindName, slug2, {
+        platformId: channelId,
+        platform: "slack",
+        name,
+        type: "channel"
+      });
+    }
+    return slug2;
+  }
+  const openData = await slackApi(token, "conversations.open", {
+    users: ids.join(",")
+  });
+  const platformId = openData.channel.id;
+  const slug = participants.length === 1 ? `slack:@${slugify(participants[0])}` : `slack:@${participants.map(slugify).sort().join(",")}`;
+  if (mindName) {
+    writeChannelEntry(mindName, slug, {
+      platformId,
+      platform: "slack",
+      name: participants.join(", "),
+      type: participants.length === 1 ? "dm" : "group"
+    });
+  }
+  return slug;
+}
+
+// src/lib/channels/telegram.ts
+var telegram_exports = {};
+__export(telegram_exports, {
+  createConversation: () => createConversation4,
+  listConversations: () => listConversations3,
+  listUsers: () => listUsers4,
+  read: () => read3,
+  send: () => send3
+});
+var TELEGRAM_MAX_LENGTH = 4096;
+var API_BASE3 = "https://api.telegram.org";
+function requireToken3(env) {
+  const token = env.TELEGRAM_BOT_TOKEN;
+  if (!token) throw new Error("TELEGRAM_BOT_TOKEN not set");
+  return token;
+}
+async function read3(_env, _channelSlug, _limit) {
+  throw new Error(
+    "Telegram Bot API does not support reading chat history. Use volute send instead."
+  );
+}
+async function send3(env, channelSlug, message, images) {
+  const token = requireToken3(env);
+  const chatId = resolveChannelId2(env, channelSlug);
+  if (images?.length) {
+    const CAPTION_MAX = 1024;
+    for (let i = 0; i < images.length; i++) {
+      const img = images[i];
+      const ext = img.media_type.split("/")[1] || "png";
+      const form = new FormData();
+      form.append("chat_id", chatId);
+      form.append(
+        "photo",
+        new Blob([Buffer.from(img.data, "base64")], { type: img.media_type }),
+        `image.${ext}`
+      );
+      if (i === 0 && message) {
+        form.append("caption", message.slice(0, CAPTION_MAX));
+      }
+      const res = await fetch(`${API_BASE3}/bot${token}/sendPhoto`, {
+        method: "POST",
+        body: form
+      });
+      if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        const partial = i > 0 ? ` (${i}/${images.length} images were already sent)` : "";
+        throw new Error(`Telegram API error: ${res.status} ${body}${partial}`);
+      }
+    }
+    if (message && message.length > CAPTION_MAX) {
+      const remaining = message.slice(CAPTION_MAX);
+      const chunks2 = splitMessage(remaining, TELEGRAM_MAX_LENGTH);
+      for (const chunk of chunks2) {
+        const res = await fetch(`${API_BASE3}/bot${token}/sendMessage`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ chat_id: chatId, text: chunk })
+        });
+        if (!res.ok) {
+          const body = await res.text().catch(() => "");
+          throw new Error(`Telegram API error: ${res.status} ${body}`);
+        }
+      }
+    }
+    return;
+  }
+  const chunks = splitMessage(message, TELEGRAM_MAX_LENGTH);
+  for (let i = 0; i < chunks.length; i++) {
+    const res = await fetch(`${API_BASE3}/bot${token}/sendMessage`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ chat_id: chatId, text: chunks[i] })
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      const partial = i > 0 ? ` (${i}/${chunks.length} chunks were already sent)` : "";
+      throw new Error(`Telegram API error: ${res.status} ${body}${partial}`);
+    }
+  }
+}
+async function listConversations3() {
+  throw new Error(
+    "Telegram Bot API does not support listing conversations. Users must message the bot first."
+  );
+}
+async function listUsers4() {
+  throw new Error(
+    "Telegram Bot API does not support listing users. Users must message the bot first."
+  );
+}
+async function createConversation4() {
+  throw new Error(
+    "Telegram Bot API does not support creating conversations. Users must message the bot first."
+  );
+}
+
+// src/lib/channels/volute.ts
+var volute_exports = {};
+__export(volute_exports, {
+  createConversation: () => createConversation5,
+  listConversations: () => listConversations4,
+  listUsers: () => listUsers5,
+  read: () => read4,
+  send: () => send4
+});
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
+import { resolve as resolve8 } from "path";
+function getDaemonConfig() {
+  const configPath2 = resolve8(voluteHome(), "daemon.json");
+  if (!existsSync7(configPath2)) {
+    throw new Error("Volute daemon is not running");
+  }
+  let config;
+  try {
+    config = JSON.parse(readFileSync5(configPath2, "utf-8"));
+  } catch (err) {
+    throw new Error(`Failed to parse ${configPath2}: ${err}`);
+  }
+  if (typeof config.port !== "number") {
+    throw new Error(`Invalid or missing port in ${configPath2}`);
+  }
+  const url = new URL("http://localhost");
+  url.hostname = config.hostname || "localhost";
+  url.port = String(config.port);
+  return { url: url.origin, token: config.token };
+}
+async function read4(env, channelSlug, limit) {
+  const mindName = env.VOLUTE_MIND;
+  if (!mindName) throw new Error("VOLUTE_MIND not set");
+  const conversationId = resolveChannelId2(env, channelSlug);
+  const { url, token } = getDaemonConfig();
+  const headers = { Origin: url };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const res = await fetch(
+    `${url}/api/minds/${encodeURIComponent(mindName)}/conversations/${encodeURIComponent(conversationId)}/messages`,
+    { headers }
+  );
+  if (!res.ok) {
+    throw new Error(`Failed to read conversation: ${res.status} ${res.statusText}`);
+  }
+  const messages2 = await res.json();
+  return messages2.slice(-limit).map((m) => {
+    const text = Array.isArray(m.content) ? m.content.filter((b) => b.type === "text").map((b) => b.text).join("") : m.content;
+    return `${m.sender_name ?? m.role}: ${text}`;
+  }).join("\n");
+}
+async function send4(env, channelSlug, message, images) {
+  const mindName = env.VOLUTE_MIND;
+  if (!mindName) throw new Error("VOLUTE_MIND not set");
+  const conversationId = resolveChannelId2(env, channelSlug);
+  const { url, token } = getDaemonConfig();
+  const headers = {
+    "Content-Type": "application/json",
+    Origin: url
+  };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const res = await fetch(`${url}/api/minds/${encodeURIComponent(mindName)}/chat`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      message,
+      conversationId,
+      sender: env.VOLUTE_SENDER ?? mindName,
+      images
+    })
+  });
+  if (!res.ok) {
+    const data = await res.json().catch(() => ({}));
+    throw new Error(data.error ?? `Failed to send: ${res.status}`);
+  }
+}
+async function listConversations4(env) {
+  const mindName = env.VOLUTE_MIND;
+  if (!mindName) throw new Error("VOLUTE_MIND not set");
+  const { url, token } = getDaemonConfig();
+  const headers = { Origin: url };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const res = await fetch(`${url}/api/minds/${encodeURIComponent(mindName)}/conversations`, {
+    headers
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to list conversations: ${res.status} ${res.statusText}`);
+  }
+  const convs = await res.json();
+  const results = [];
+  for (const conv of convs) {
+    let participants = [];
+    try {
+      const pRes = await fetch(
+        `${url}/api/minds/${encodeURIComponent(mindName)}/conversations/${encodeURIComponent(conv.id)}/participants`,
+        { headers }
+      );
+      if (pRes.ok) {
+        participants = await pRes.json();
+      } else {
+        console.error(`[volute] failed to fetch participants for ${conv.id}: HTTP ${pRes.status}`);
+      }
+    } catch (err) {
+      console.error(`[volute] failed to fetch participants for ${conv.id}:`, err);
+    }
+    const slug = buildVoluteSlug({
+      participants,
+      mindUsername: mindName,
+      convTitle: conv.title,
+      conversationId: conv.id,
+      convType: conv.type,
+      convName: conv.name
+    });
+    const convType = conv.type === "channel" ? "channel" : participants.length === 2 ? "dm" : "group";
+    results.push({
+      id: slug,
+      platformId: conv.id,
+      name: conv.type === "channel" ? `#${conv.name}` : conv.title ?? "(untitled)",
+      type: convType,
+      participantCount: participants.length
+    });
+  }
+  return results;
+}
+async function listUsers5(_env) {
+  const { url, token } = getDaemonConfig();
+  const headers = { Origin: url };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const res = await fetch(`${url}/api/auth/users`, { headers });
+  if (!res.ok) {
+    throw new Error(`Failed to list users: ${res.status} ${res.statusText}`);
   }
-  return c.json({ id: user.id, username: user.username, role: user.role });
-}).post("/login", zValidator("json", credentialsSchema), async (c) => {
-  const { username, password } = c.req.valid("json");
-  const user = await verifyUser(username, password);
-  if (!user) {
-    return c.json({ error: "Invalid credentials" }, 401);
+  const data = await res.json();
+  return data.map((u) => ({
+    id: String(u.id),
+    username: u.username,
+    type: u.user_type
+  }));
+}
+async function createConversation5(env, participants, name) {
+  const mindName = env.VOLUTE_MIND;
+  if (!mindName) throw new Error("VOLUTE_MIND not set");
+  const { url, token } = getDaemonConfig();
+  const headers = {
+    "Content-Type": "application/json",
+    Origin: url
+  };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const res = await fetch(`${url}/api/minds/${encodeURIComponent(mindName)}/conversations`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ participantNames: participants, title: name })
+  });
+  if (!res.ok) {
+    const data = await res.json().catch(() => ({}));
+    throw new Error(data.error ?? `Failed to create conversation: ${res.status}`);
   }
-  const sessionId = await createSession(user.id);
-  setCookie(c, "volute_session", sessionId, { path: "/", httpOnly: true, sameSite: "Lax" });
-  return c.json({ id: user.id, username: user.username, role: user.role });
-}).post("/logout", async (c) => {
-  const sessionId = getCookie2(c, "volute_session");
-  if (sessionId) {
-    await deleteSession(sessionId);
-    deleteCookie(c, "volute_session", { path: "/" });
+  const conv = await res.json();
+  return `volute:${conv.id}`;
+}
+
+// src/lib/channels.ts
+var CHANNELS = {
+  volute: {
+    name: "volute",
+    displayName: "Volute",
+    showToolCalls: true,
+    builtIn: true,
+    driver: volute_exports
+  },
+  discord: {
+    name: "discord",
+    displayName: "Discord",
+    showToolCalls: false,
+    driver: discord_exports
+  },
+  slack: {
+    name: "slack",
+    displayName: "Slack",
+    showToolCalls: false,
+    driver: slack_exports
+  },
+  telegram: {
+    name: "telegram",
+    displayName: "Telegram",
+    showToolCalls: false,
+    driver: telegram_exports
+  },
+  mail: { name: "mail", displayName: "Email", showToolCalls: false },
+  system: { name: "system", displayName: "System", showToolCalls: false }
+};
+function getChannelDriver(platform) {
+  return CHANNELS[platform]?.driver ?? null;
+}
+function resolveChannelId2(env, slug) {
+  const mindName = env.VOLUTE_MIND;
+  if (!mindName) {
+    const colonIdx = slug.indexOf(":");
+    return colonIdx !== -1 ? slug.slice(colonIdx + 1) : slug;
   }
-  return c.json({ ok: true });
-}).get("/me", async (c) => {
-  const sessionId = getCookie2(c, "volute_session");
-  if (!sessionId) return c.json({ error: "Not logged in" }, 401);
-  const userId = await getSessionUserId(sessionId);
-  if (userId == null) return c.json({ error: "Not logged in" }, 401);
-  const user = await getUser(userId);
-  if (!user) return c.json({ error: "Not logged in" }, 401);
-  return c.json({ id: user.id, username: user.username, role: user.role });
-}).route("/", admin).route("/", authenticated);
-var auth_default = app2;
+  return resolveChannelId(mindName, slug);
+}
 
 // src/web/api/channels.ts
-import { Hono as Hono3 } from "hono";
 function buildEnv(name) {
   return { ...loadMergedEnv(name), VOLUTE_MIND: name, VOLUTE_MIND_DIR: mindDir(name) };
 }
 var app3 = new Hono3().post("/:name/channels/send", requireAdmin, async (c) => {
   const name = c.req.param("name");
   if (!findMind(name)) return c.json({ error: "Mind not found" }, 404);
-  const { platform, uri, message, images } = await c.req.json();
+  const { platform, uri, message, images, sender } = await c.req.json();
   const driver = getChannelDriver(platform);
   if (!driver) return c.json({ error: `No driver for platform: ${platform}` }, 400);
   const env = buildEnv(name);
+  if (sender) env.VOLUTE_SENDER = sender;
   try {
     await driver.send(env, uri, message, images);
     return c.json({ ok: true });
@@ -2181,13 +2883,15 @@ var app3 = new Hono3().post("/:name/channels/send", requireAdmin, async (c) => {
   const {
     platform,
     participants,
-    name: convName
+    name: convName,
+    sender
   } = await c.req.json();
   const driver = getChannelDriver(platform);
   if (!driver?.createConversation) {
     return c.json({ error: `Platform ${platform} does not support creating conversations` }, 400);
   }
   const env = buildEnv(name);
+  if (sender) env.VOLUTE_SENDER = sender;
   try {
     const slug = await driver.createConversation(env, participants, convName);
     return c.json({ slug });
@@ -2351,14 +3055,14 @@ var sharedEnvApp = new Hono5().get("/", (c) => {
 var env_default = app5;
 
 // src/web/api/file-sharing.ts
-import { readFileSync as readFileSync6, statSync as statSync2 } from "fs";
-import { resolve as resolve9 } from "path";
+import { readFileSync as readFileSync7, statSync as statSync2 } from "fs";
+import { resolve as resolve10 } from "path";
 import { Hono as Hono6 } from "hono";
 
 // src/lib/file-sharing.ts
 import { randomBytes } from "crypto";
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readdirSync as readdirSync3, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync4 } from "fs";
-import { basename, join as join2, normalize, resolve as resolve8 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readdirSync as readdirSync3, readFileSync as readFileSync6, rmSync, writeFileSync as writeFileSync4 } from "fs";
+import { basename, join as join2, normalize, resolve as resolve9 } from "path";
 function validateFilePath(filePath) {
   if (!filePath) return "File path is required";
   const normalized = normalize(filePath);
@@ -2371,13 +3075,13 @@ function validateFilePath(filePath) {
   return null;
 }
 function configPath(dir) {
-  return resolve8(dir, "home", ".config", "file-sharing.json");
+  return resolve9(dir, "home", ".config", "file-sharing.json");
 }
 function readFileSharingConfig(dir) {
   const p = configPath(dir);
-  if (!existsSync7(p)) return {};
+  if (!existsSync8(p)) return {};
   try {
-    return JSON.parse(readFileSync5(p, "utf-8"));
+    return JSON.parse(readFileSync6(p, "utf-8"));
   } catch (err) {
     console.warn(`[file-sharing] failed to parse config at ${p}:`, err);
     return {};
@@ -2385,7 +3089,7 @@ function readFileSharingConfig(dir) {
 }
 function writeFileSharingConfig(dir, config) {
   const p = configPath(dir);
-  mkdirSync4(resolve8(p, ".."), { recursive: true });
+  mkdirSync4(resolve9(p, ".."), { recursive: true });
   writeFileSync4(p, `${JSON.stringify(config, null, 2)}
 `);
 }
@@ -2409,7 +3113,7 @@ function removeTrust(dir, sender) {
   writeFileSharingConfig(dir, config);
 }
 function pendingDir(receiver) {
-  return resolve8(stateDir(receiver), "pending-files");
+  return resolve9(stateDir(receiver), "pending-files");
 }
 function validateId(id) {
   if (!id || id.includes("/") || id.includes("\\") || id.includes("..")) {
@@ -2428,7 +3132,7 @@ function stageFile(receiver, sender, filename, content, originalPath) {
     throw new Error("Invalid sender name");
   }
   const id = generateId(sender);
-  const dir = resolve8(pendingDir(receiver), id);
+  const dir = resolve9(pendingDir(receiver), id);
   mkdirSync4(dir, { recursive: true });
   const metadata = {
     id,
@@ -2438,22 +3142,22 @@ function stageFile(receiver, sender, filename, content, originalPath) {
     size: content.length,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  writeFileSync4(resolve8(dir, "metadata.json"), `${JSON.stringify(metadata, null, 2)}
+  writeFileSync4(resolve9(dir, "metadata.json"), `${JSON.stringify(metadata, null, 2)}
 `);
-  writeFileSync4(resolve8(dir, "data"), content);
+  writeFileSync4(resolve9(dir, "data"), content);
   return { id };
 }
 function listPending(receiver) {
   const dir = pendingDir(receiver);
-  if (!existsSync7(dir)) return [];
+  if (!existsSync8(dir)) return [];
   const entries = readdirSync3(dir, { withFileTypes: true });
   const result = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const metaPath = resolve8(dir, entry.name, "metadata.json");
-    if (!existsSync7(metaPath)) continue;
+    const metaPath = resolve9(dir, entry.name, "metadata.json");
+    if (!existsSync8(metaPath)) continue;
     try {
-      result.push(JSON.parse(readFileSync5(metaPath, "utf-8")));
+      result.push(JSON.parse(readFileSync6(metaPath, "utf-8")));
     } catch (err) {
       console.warn(`[file-sharing] skipping malformed pending entry ${entry.name}:`, err);
     }
@@ -2462,10 +3166,10 @@ function listPending(receiver) {
 }
 function getPending(receiver, id) {
   validateId(id);
-  const metaPath = resolve8(pendingDir(receiver), id, "metadata.json");
-  if (!existsSync7(metaPath)) return null;
+  const metaPath = resolve9(pendingDir(receiver), id, "metadata.json");
+  if (!existsSync8(metaPath)) return null;
   try {
-    return JSON.parse(readFileSync5(metaPath, "utf-8"));
+    return JSON.parse(readFileSync6(metaPath, "utf-8"));
   } catch (err) {
     console.warn(`[file-sharing] failed to read pending metadata for ${id}:`, err);
     return null;
@@ -2480,27 +3184,27 @@ function deliverFile(receiverDir, sender, filename, content, inboxPath) {
   if (sender.includes("/") || sender.includes("\\")) {
     throw new Error("Invalid sender name");
   }
-  const destDir = resolve8(receiverDir, "home", inbox, sender);
+  const destDir = resolve9(receiverDir, "home", inbox, sender);
   mkdirSync4(destDir, { recursive: true });
-  const destPath = resolve8(destDir, basename(filename));
+  const destPath = resolve9(destDir, basename(filename));
   writeFileSync4(destPath, content);
   return join2(inbox, sender, basename(filename));
 }
 function acceptPending(receiver, id, receiverDir) {
   const meta = getPending(receiver, id);
   if (!meta) throw new Error(`Pending file not found: ${id}`);
-  const dataPath = resolve8(pendingDir(receiver), id, "data");
-  const content = readFileSync5(dataPath);
+  const dataPath = resolve9(pendingDir(receiver), id, "data");
+  const content = readFileSync6(dataPath);
   const config = readFileSharingConfig(receiverDir);
   const inboxPath = config.inboxPath ?? "inbox";
   const destPath = deliverFile(receiverDir, meta.sender, meta.filename, content, inboxPath);
-  rmSync(resolve8(pendingDir(receiver), id), { recursive: true });
+  rmSync(resolve9(pendingDir(receiver), id), { recursive: true });
   return { sender: meta.sender, filename: meta.filename, destPath };
 }
 function rejectPending(receiver, id) {
   const meta = getPending(receiver, id);
   if (!meta) throw new Error(`Pending file not found: ${id}`);
-  rmSync(resolve8(pendingDir(receiver), id), { recursive: true });
+  rmSync(resolve9(pendingDir(receiver), id), { recursive: true });
   return { sender: meta.sender, filename: meta.filename };
 }
 function formatFileSize(bytes) {
@@ -2541,21 +3245,21 @@ var app6 = new Hono6().post("/:name/files/send", async (c) => {
   const pathErr = validateFilePath(body.filePath);
   if (pathErr) return c.json({ error: pathErr }, 400);
   const senderDir = mindDir(senderName);
-  const filePath = resolve9(senderDir, "home", body.filePath);
+  const filePath = resolve10(senderDir, "home", body.filePath);
   const MAX_FILE_SIZE = 50 * 1024 * 1024;
-  const stat3 = statSync2(filePath, { throwIfNoEntry: false });
-  if (!stat3) return c.json({ error: `File not found: ${body.filePath}` }, 404);
-  if (stat3.size > MAX_FILE_SIZE) {
+  const stat4 = statSync2(filePath, { throwIfNoEntry: false });
+  if (!stat4) return c.json({ error: `File not found: ${body.filePath}` }, 404);
+  if (stat4.size > MAX_FILE_SIZE) {
     return c.json(
       {
-        error: `File too large (${formatFileSize(stat3.size)}, max ${formatFileSize(MAX_FILE_SIZE)})`
+        error: `File too large (${formatFileSize(stat4.size)}, max ${formatFileSize(MAX_FILE_SIZE)})`
       },
       413
     );
   }
   let content;
   try {
-    content = readFileSync6(filePath);
+    content = readFileSync7(filePath);
   } catch {
     return c.json({ error: `File not found: ${body.filePath}` }, 404);
   }
@@ -2657,18 +3361,61 @@ var app6 = new Hono6().post("/:name/files/send", async (c) => {
 var file_sharing_default = app6;
 
 // src/web/api/files.ts
-import { existsSync as existsSync8 } from "fs";
-import { readdir, readFile } from "fs/promises";
-import { resolve as resolve10 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { readdir, readFile, realpath, stat } from "fs/promises";
+import { extname, resolve as resolve11 } from "path";
 import { Hono as Hono7 } from "hono";
 var ALLOWED_FILES = /* @__PURE__ */ new Set(["SOUL.md", "MEMORY.md", "CLAUDE.md", "VOLUTE.md"]);
-var app7 = new Hono7().get("/:name/files", async (c) => {
+var AVATAR_MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp"
+};
+var MAX_AVATAR_SIZE = 2 * 1024 * 1024;
+var app7 = new Hono7().get("/:name/avatar", async (c) => {
+  const name = c.req.param("name");
+  const entry = findMind(name);
+  if (!entry) return c.json({ error: "Mind not found" }, 404);
+  const dir = mindDir(name);
+  const config = readVoluteConfig(dir);
+  if (!config?.avatar) return c.json({ error: "No avatar configured" }, 404);
+  const ext = extname(config.avatar).toLowerCase();
+  const mime = AVATAR_MIME[ext];
+  if (!mime) return c.json({ error: "Invalid avatar extension" }, 400);
+  const homeDir = resolve11(dir, "home");
+  const avatarPath = resolve11(homeDir, config.avatar);
+  if (!avatarPath.startsWith(`${homeDir}/`)) return c.json({ error: "Invalid avatar path" }, 400);
+  let realAvatarPath;
+  try {
+    const realHome = await realpath(homeDir);
+    realAvatarPath = await realpath(avatarPath);
+    if (!realAvatarPath.startsWith(`${realHome}/`))
+      return c.json({ error: "Invalid avatar path" }, 400);
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return c.json({ error: "Avatar file not found" }, 404);
+    return c.json({ error: "Failed to resolve avatar path" }, 500);
+  }
+  try {
+    const fileStat = await stat(realAvatarPath);
+    if (fileStat.size > MAX_AVATAR_SIZE) return c.json({ error: "Avatar file too large" }, 400);
+    const body = await readFile(realAvatarPath);
+    return c.body(body, 200, {
+      "Content-Type": mime,
+      "Cache-Control": "public, max-age=300"
+    });
+  } catch {
+    return c.json({ error: "Failed to read avatar file" }, 500);
+  }
+}).get("/:name/files", async (c) => {
   const name = c.req.param("name");
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const dir = mindDir(name);
-  const homeDir = resolve10(dir, "home");
-  if (!existsSync8(homeDir)) return c.json({ error: "Home directory missing" }, 404);
+  const homeDir = resolve11(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);
@@ -2681,8 +3428,8 @@ var app7 = new Hono7().get("/:name/files", async (c) => {
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const dir = mindDir(name);
-  const filePath = resolve10(dir, "home", filename);
-  if (!existsSync8(filePath)) {
+  const filePath = resolve11(dir, "home", filename);
+  if (!existsSync9(filePath)) {
     return c.json({ error: "File not found" }, 404);
   }
   const content = await readFile(filePath, "utf-8");
@@ -2695,17 +3442,17 @@ import { Hono as Hono8 } 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 writeFileSync5 } from "fs";
-import { resolve as resolve11 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
+import { resolve as resolve12 } from "path";
 function generateIdentity(mindDir2) {
-  const identityDir = resolve11(mindDir2, ".mind/identity");
+  const identityDir = resolve12(mindDir2, ".mind/identity");
   mkdirSync5(identityDir, { recursive: true });
   const { publicKey, privateKey } = generateKeyPairSync("ed25519", {
     publicKeyEncoding: { type: "spki", format: "pem" },
     privateKeyEncoding: { type: "pkcs8", format: "pem" }
   });
-  const privatePath = resolve11(identityDir, "private.pem");
-  const publicPath = resolve11(identityDir, "public.pem");
+  const privatePath = resolve12(identityDir, "private.pem");
+  const publicPath = resolve12(identityDir, "public.pem");
   writeFileSync5(privatePath, privateKey, { mode: 384 });
   writeFileSync5(publicPath, publicKey, { mode: 420 });
   const config = readVoluteConfig(mindDir2) ?? {};
@@ -2720,17 +3467,17 @@ function getPrivateKey(mindDir2) {
   const config = readVoluteConfig(mindDir2);
   const relPath = config?.identity?.privateKey;
   if (!relPath) return null;
-  const fullPath = resolve11(mindDir2, relPath);
-  if (!existsSync9(fullPath)) return null;
-  return readFileSync7(fullPath, "utf-8");
+  const fullPath = resolve12(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 = resolve11(mindDir2, relPath);
-  if (!existsSync9(fullPath)) return null;
-  return readFileSync7(fullPath, "utf-8");
+  const fullPath = resolve12(mindDir2, relPath);
+  if (!existsSync10(fullPath)) return null;
+  return readFileSync8(fullPath, "utf-8");
 }
 function getFingerprint(publicKeyPem) {
   return createHash("sha256").update(publicKeyPem).digest("hex");
@@ -2783,16 +3530,16 @@ var keys_default = app8;
 
 // src/web/api/logs.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync10 } from "fs";
-import { resolve as resolve12 } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { resolve as resolve13 } from "path";
 import { Hono as Hono9 } from "hono";
 import { streamSSE as streamSSE2 } from "hono/streaming";
 var app9 = new Hono9().get("/:name/logs", async (c) => {
   const name = c.req.param("name");
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const logFile = resolve12(stateDir(name), "logs", "mind.log");
-  if (!existsSync10(logFile)) {
+  const logFile = resolve13(stateDir(name), "logs", "mind.log");
+  if (!existsSync11(logFile)) {
     return c.json({ error: "No log file found" }, 404);
   }
   return streamSSE2(c, async (stream) => {
@@ -2819,8 +3566,8 @@ var app9 = new Hono9().get("/:name/logs", async (c) => {
   const name = c.req.param("name");
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const logFile = resolve12(stateDir(name), "logs", "mind.log");
-  if (!existsSync10(logFile)) {
+  const logFile = resolve13(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);
@@ -2920,13 +3667,13 @@ var mind_skills_default = app10;
 
 // src/web/api/minds.ts
 import {
-  cpSync as cpSync2,
+  cpSync,
   existsSync as existsSync12,
-  mkdirSync as mkdirSync8,
-  readdirSync as readdirSync6,
+  mkdirSync as mkdirSync7,
+  readdirSync as readdirSync5,
   readFileSync as readFileSync11,
-  rmSync as rmSync3,
-  writeFileSync as writeFileSync9
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync8
 } from "fs";
 import { resolve as resolve16 } from "path";
 import { zValidator as zValidator3 } from "@hono/zod-validator";
@@ -2935,19 +3682,19 @@ import { Hono as Hono11 } from "hono";
 import { z as z3 } from "zod";
 
 // src/lib/consolidate.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
-import { resolve as resolve13 } from "path";
+import { readdirSync as readdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
+import { resolve as resolve14 } from "path";
 async function consolidateMemory(mindDir2) {
-  const soulPath = resolve13(mindDir2, "home/SOUL.md");
-  const memoryPath = resolve13(mindDir2, "home/MEMORY.md");
-  const memoryDir = resolve13(mindDir2, "home/memory");
-  const soul = readFileSync8(soulPath, "utf-8");
+  const soulPath = resolve14(mindDir2, "home/SOUL.md");
+  const memoryPath = resolve14(mindDir2, "home/MEMORY.md");
+  const memoryDir = resolve14(mindDir2, "home/memory");
+  const soul = readFileSync9(soulPath, "utf-8");
   const logs = [];
   try {
     const files = readdirSync4(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(resolve13(memoryDir, filename), "utf-8").trim();
+      const content2 = readFileSync9(resolve14(memoryDir, filename), "utf-8").trim();
       if (content2) {
         logs.push(`### ${date}
 
@@ -3007,11 +3754,11 @@ ${content2}`);
 
 // src/lib/convert-session.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "fs";
 import { homedir } from "os";
-import { resolve as resolve14 } from "path";
+import { resolve as resolve15 } 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 = randomUUID2();
   const idMap = /* @__PURE__ */ new Map();
   const messages2 = [];
@@ -3125,9 +3872,9 @@ function convertSession(opts) {
     }
   }
   const projectId = opts.projectDir.replace(/\//g, "-");
-  const sdkDir = resolve14(homedir(), ".claude", "projects", projectId);
+  const sdkDir = resolve15(homedir(), ".claude", "projects", projectId);
   mkdirSync6(sdkDir, { recursive: true });
-  const sdkPath = resolve14(sdkDir, `${sessionId}.jsonl`);
+  const sdkPath = resolve15(sdkDir, `${sessionId}.jsonl`);
   writeFileSync7(sdkPath, `${sdkEvents.join("\n")}
 `);
   console.log(`Converted ${sdkEvents.length} messages \u2192 ${sdkPath}`);
@@ -3179,7 +3926,7 @@ function convertAssistantContent(content) {
   return result;
 }
 
-// src/lib/mind-events.ts
+// src/lib/events/mind-events.ts
 var subscribers = /* @__PURE__ */ new Map();
 function subscribe3(mind, callback) {
   let set = subscribers.get(mind);
@@ -3207,111 +3954,6 @@ function publish3(mind, event) {
   }
 }
 
-// src/lib/template.ts
-import {
-  cpSync,
-  existsSync as existsSync11,
-  mkdirSync as mkdirSync7,
-  readdirSync as readdirSync5,
-  readFileSync as readFileSync10,
-  renameSync as renameSync3,
-  rmSync as rmSync2,
-  statSync as statSync3,
-  writeFileSync as writeFileSync8
-} from "fs";
-import { tmpdir } from "os";
-import { dirname as dirname2, join as join3, relative, resolve as resolve15 } from "path";
-function findTemplatesRoot() {
-  let dir = dirname2(new URL(import.meta.url).pathname);
-  for (let i = 0; i < 5; i++) {
-    const candidate = resolve15(dir, "templates");
-    if (existsSync11(resolve15(candidate, "_base"))) return candidate;
-    dir = dirname2(dir);
-  }
-  console.error(
-    "Templates directory not found. Searched up from:",
-    dirname2(new URL(import.meta.url).pathname)
-  );
-  process.exit(1);
-}
-function composeTemplate(templatesRoot, templateName) {
-  const baseDir = resolve15(templatesRoot, "_base");
-  const templateDir = resolve15(templatesRoot, templateName);
-  if (!existsSync11(baseDir)) {
-    console.error("Base template not found:", baseDir);
-    process.exit(1);
-  }
-  if (!existsSync11(templateDir)) {
-    console.error(`Template not found: ${templateName}`);
-    process.exit(1);
-  }
-  const composedDir = resolve15(tmpdir(), `volute-template-${Date.now()}`);
-  mkdirSync7(composedDir, { recursive: true });
-  cpSync(baseDir, composedDir, { recursive: true });
-  for (const file of listFiles(templateDir)) {
-    const src = resolve15(templateDir, file);
-    const dest = resolve15(composedDir, file);
-    mkdirSync7(dirname2(dest), { recursive: true });
-    cpSync(src, dest);
-  }
-  const manifestPath = resolve15(composedDir, "volute-template.json");
-  if (!existsSync11(manifestPath)) {
-    rmSync2(composedDir, { recursive: true, force: true });
-    console.error(`Template manifest not found: ${templateName}/volute-template.json`);
-    process.exit(1);
-  }
-  const manifest = JSON.parse(readFileSync10(manifestPath, "utf-8"));
-  rmSync2(manifestPath);
-  return { composedDir, manifest };
-}
-function copyTemplateToDir(composedDir, destDir, mindName, manifest) {
-  cpSync(composedDir, destDir, { recursive: true });
-  for (const [from, to] of Object.entries(manifest.rename)) {
-    const fromPath = resolve15(destDir, from);
-    if (existsSync11(fromPath)) {
-      renameSync3(fromPath, resolve15(destDir, to));
-    }
-  }
-  for (const file of manifest.substitute) {
-    const path = resolve15(destDir, file);
-    if (existsSync11(path)) {
-      const content = readFileSync10(path, "utf-8");
-      writeFileSync8(path, content.replaceAll("{{name}}", mindName));
-    }
-  }
-}
-function applyInitFiles(destDir) {
-  const initDir = resolve15(destDir, ".init");
-  if (!existsSync11(initDir)) return;
-  const homeDir = resolve15(destDir, "home");
-  for (const file of listFiles(initDir)) {
-    const src = resolve15(initDir, file);
-    const dest = resolve15(homeDir, file);
-    const parent = dirname2(dest);
-    if (!existsSync11(parent)) {
-      mkdirSync7(parent, { recursive: true });
-    }
-    cpSync(src, dest);
-  }
-  rmSync2(initDir, { recursive: true, force: true });
-}
-function listFiles(dir) {
-  const results = [];
-  function walk(current) {
-    for (const entry of readdirSync5(current)) {
-      const full = join3(current, entry);
-      if (statSync3(full).isDirectory()) {
-        if (entry === ".git") continue;
-        walk(full);
-      } else {
-        results.push(relative(dir, full));
-      }
-    }
-  }
-  walk(dir);
-  return results;
-}
-
 // src/web/api/minds.ts
 async function getMindStatus(name, port) {
   const manager = getMindManager();
@@ -3320,7 +3962,8 @@ async function getMindStatus(name, port) {
     const health = await checkHealth(port);
     status = health.ok ? "running" : "starting";
   }
-  const channelConfig = readVoluteConfig(mindDir(name))?.channels;
+  const config = readVoluteConfig(mindDir(name));
+  const channelConfig = config?.channels;
   const channels = [];
   for (const [, provider] of Object.entries(CHANNELS)) {
     if (!provider.builtIn) continue;
@@ -3341,7 +3984,13 @@ async function getMindStatus(name, port) {
       showToolCalls: channelConfig?.[cs.type]?.showToolCalls ?? provider?.showToolCalls ?? false
     });
   }
-  return { status, channels };
+  return {
+    status,
+    channels,
+    displayName: config?.displayName,
+    description: config?.description,
+    avatar: config?.avatar
+  };
 }
 var TEMPLATE_BRANCH = "volute/template";
 async function configureGitIdentity(mindName, opts) {
@@ -3373,7 +4022,7 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
   } catch {
   }
   if (existsSync12(tempWorktree)) {
-    rmSync3(tempWorktree, { recursive: true, force: true });
+    rmSync2(tempWorktree, { recursive: true, force: true });
   }
   const templatesRoot = findTemplatesRoot();
   const { composedDir, manifest } = composeTemplate(templatesRoot, template);
@@ -3395,7 +4044,7 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
     copyTemplateToDir(composedDir, tempWorktree, mindName, manifest);
     const initDir = resolve16(tempWorktree, ".init");
     if (existsSync12(initDir)) {
-      rmSync3(initDir, { recursive: true, force: true });
+      rmSync2(initDir, { recursive: true, force: true });
     }
     await gitExec(["add", "-A"], { cwd: tempWorktree });
     try {
@@ -3409,9 +4058,9 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
     } catch {
     }
     if (existsSync12(tempWorktree)) {
-      rmSync3(tempWorktree, { recursive: true, force: true });
+      rmSync2(tempWorktree, { recursive: true, force: true });
     }
-    rmSync3(composedDir, { recursive: true, force: true });
+    rmSync2(composedDir, { recursive: true, force: true });
   }
 }
 async function mergeTemplateBranch(worktreeDir) {
@@ -3447,6 +4096,12 @@ async function importFromArchive(c, tempDir, nameOverride, manifest) {
   if (!manifest?.includes || !manifest.name || !manifest.template) {
     return c.json({ error: "Invalid archive manifest" }, 400);
   }
+  if (isHomeOnlyArchive(manifest)) {
+    return importFromHomeOnlyArchive(c, tempDir, extractedMindDir, nameOverride, manifest);
+  }
+  return importFromFullArchive(c, tempDir, extractedMindDir, nameOverride, manifest);
+}
+async function importFromFullArchive(c, tempDir, extractedMindDir, nameOverride, manifest) {
   const name = nameOverride ?? manifest.name;
   const nameErr = validateMindName(name);
   if (nameErr) return c.json({ error: nameErr }, 400);
@@ -3455,93 +4110,220 @@ async function importFromArchive(c, tempDir, nameOverride, manifest) {
   const dest = mindDir(name);
   if (existsSync12(dest)) return c.json({ error: "Mind directory already exists" }, 409);
   try {
-    cpSync2(extractedMindDir, dest, { recursive: true });
+    cpSync(extractedMindDir, dest, { recursive: true });
     if (!manifest.includes.identity) {
       generateIdentity(dest);
     }
     const state = stateDir(name);
-    mkdirSync8(state, { recursive: true });
+    mkdirSync7(state, { recursive: true });
     const channelsJson = resolve16(tempDir, "state/channels.json");
     if (existsSync12(channelsJson)) {
-      cpSync2(channelsJson, resolve16(state, "channels.json"));
+      cpSync(channelsJson, resolve16(state, "channels.json"));
     }
     const envJson = resolve16(tempDir, "state/env.json");
     if (existsSync12(envJson)) {
-      cpSync2(envJson, resolve16(state, "env.json"));
+      cpSync(envJson, resolve16(state, "env.json"));
     }
     const port = nextPort();
-    addMind(name, port, void 0, manifest.template);
+    addMind(name, port, manifest.stage, manifest.template);
+    try {
+      setMindTemplateHash(name, computeTemplateHash(manifest.template));
+    } catch (err) {
+      logger_default.warn(`failed to set template hash for ${name}`, logger_default.errorData(err));
+    }
     const homeDir = resolve16(dest, "home");
     ensureVoluteGroup();
     createMindUser(name, homeDir);
     chownMindDir(dest, name);
     await npmInstallAsMind(dest, name);
-    const historyJsonl = resolve16(tempDir, "history.jsonl");
-    if (existsSync12(historyJsonl)) {
+    await importHistoryFromArchive(name, tempDir);
+    importSessionsFromArchive(dest, tempDir);
+    if (!existsSync12(resolve16(dest, ".git"))) {
       try {
-        const db = await getDb();
-        const lines = readFileSync11(historyJsonl, "utf-8").trim().split("\n");
-        let imported = 0;
-        let failed = 0;
-        for (const line of lines) {
-          if (!line) continue;
-          try {
-            const row = JSON.parse(line);
-            if (!row.type) {
-              failed++;
-              continue;
-            }
-            await db.insert(mindHistory).values({
-              mind: name,
-              channel: row.channel ?? null,
-              session: row.session ?? null,
-              sender: row.sender ?? null,
-              message_id: row.message_id ?? null,
-              type: row.type,
-              content: row.content ?? null,
-              metadata: row.metadata ?? null,
-              created_at: row.created_at ?? (/* @__PURE__ */ new Date()).toISOString()
-            });
-            imported++;
-          } catch (lineErr) {
-            logger_default.warn("Failed to import history line", logger_default.errorData(lineErr));
-            failed++;
-          }
-        }
-        if (failed > 0) {
-          logger_default.warn(`History import: ${imported} imported, ${failed} failed`);
-        }
+        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("Failed to open database for history import", logger_default.errorData(err));
+        logger_default.error(`git setup failed for imported mind ${name}`, logger_default.errorData(err));
+        rmSync2(resolve16(dest, ".git"), { recursive: true, force: true });
       }
     }
-    const sessionsDir = resolve16(tempDir, "sessions");
-    if (existsSync12(sessionsDir)) {
-      const destSessions = resolve16(dest, ".mind/sessions");
-      mkdirSync8(destSessions, { recursive: true });
-      for (const file of readdirSync6(sessionsDir)) {
-        cpSync2(resolve16(sessionsDir, file), resolve16(destSessions, file));
-      }
+    chownMindDir(dest, name);
+    rmSync2(tempDir, { recursive: true, force: true });
+    return c.json({ ok: true, name, port, message: `Imported mind: ${name} (port ${port})` });
+  } catch (err) {
+    if (existsSync12(dest)) rmSync2(dest, { recursive: true, force: true });
+    try {
+      removeMind(name);
+    } catch (cleanupErr) {
+      logger_default.error(`Failed to clean up registry for ${name}`, logger_default.errorData(cleanupErr));
     }
-    if (!existsSync12(resolve16(dest, ".git"))) {
-      const env = isIsolationEnabled() ? { ...process.env, HOME: resolve16(dest, "home") } : void 0;
+    rmSync2(tempDir, { recursive: true, force: true });
+    return c.json({ error: err instanceof Error ? err.message : "Failed to import mind" }, 500);
+  }
+}
+async function importFromHomeOnlyArchive(c, tempDir, extractedMindDir, nameOverride, manifest) {
+  const name = nameOverride ?? manifest.name;
+  const nameErr = validateMindName(name);
+  if (nameErr) return c.json({ error: nameErr }, 400);
+  if (findMind(name)) return c.json({ error: `Mind already exists: ${name}` }, 409);
+  ensureVoluteHome();
+  const dest = mindDir(name);
+  if (existsSync12(dest)) return c.json({ error: "Mind directory already exists" }, 409);
+  const templatesRoot = findTemplatesRoot();
+  const { composedDir, manifest: templateManifest } = composeTemplate(
+    templatesRoot,
+    manifest.template
+  );
+  try {
+    copyTemplateToDir(composedDir, dest, name, templateManifest);
+    applyInitFiles(dest);
+    const extractedHome = resolve16(extractedMindDir, "home");
+    if (existsSync12(extractedHome)) {
+      cpSync(extractedHome, resolve16(dest, "home"), { recursive: true });
+    }
+    const extractedMindInternal = resolve16(extractedMindDir, ".mind");
+    if (existsSync12(extractedMindInternal)) {
+      cpSync(extractedMindInternal, resolve16(dest, ".mind"), { recursive: true });
+    }
+    const identityDir = resolve16(dest, ".mind/identity");
+    let publicKeyPem;
+    if (!manifest.includes.identity || !existsSync12(resolve16(identityDir, "private.pem"))) {
+      ({ publicKeyPem } = generateIdentity(dest));
+    } else {
+      publicKeyPem = readFileSync11(resolve16(identityDir, "public.pem"), "utf-8");
+    }
+    const promptsPath = resolve16(dest, "home/.config/prompts.json");
+    if (!existsSync12(promptsPath)) {
+      const mindPrompts = await getMindPromptDefaults();
+      writeFileSync8(promptsPath, `${JSON.stringify(mindPrompts, null, 2)}
+`);
+    }
+    const state = stateDir(name);
+    mkdirSync7(state, { recursive: true });
+    const channelsJson = resolve16(tempDir, "state/channels.json");
+    if (existsSync12(channelsJson)) {
+      cpSync(channelsJson, resolve16(state, "channels.json"));
+    }
+    const envJson = resolve16(tempDir, "state/env.json");
+    if (existsSync12(envJson)) {
+      cpSync(envJson, resolve16(state, "env.json"));
+    }
+    const port = nextPort();
+    addMind(name, port, manifest.stage, manifest.template);
+    const homeDir = resolve16(dest, "home");
+    ensureVoluteGroup();
+    createMindUser(name, homeDir);
+    chownMindDir(dest, name);
+    await npmInstallAsMind(dest, name);
+    let gitWarning;
+    try {
+      const env = isIsolationEnabled() ? { ...process.env, HOME: homeDir } : 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 });
+      await initTemplateBranch(dest, composedDir, templateManifest, name, env);
+    } catch (err) {
+      logger_default.error(`git setup failed for imported mind ${name}`, logger_default.errorData(err));
+      rmSync2(resolve16(dest, ".git"), { recursive: true, force: true });
+      gitWarning = "Git setup failed \u2014 variants and upgrades won't be available until git is initialized.";
+    }
+    try {
+      await addSharedWorktree(name, dest);
+    } 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 skillWarnings = [];
+    for (const skillId of skillSet) {
+      try {
+        await installSkill(name, dest, skillId);
+      } catch (err) {
+        logger_default.error(`failed to install skill ${skillId} for ${name}`, logger_default.errorData(err));
+        skillWarnings.push(`Failed to install skill: ${skillId}`);
+      }
     }
+    await importHistoryFromArchive(name, tempDir);
+    importSessionsFromArchive(dest, tempDir);
     chownMindDir(dest, name);
-    rmSync3(tempDir, { recursive: true, force: true });
-    return c.json({ ok: true, name, port, message: `Imported mind: ${name} (port ${port})` });
+    publishPublicKey(name, publicKeyPem).catch(
+      (err) => logger_default.warn(`failed to publish key for ${name}`, { error: err.message })
+    );
+    rmSync2(tempDir, { recursive: true, force: true });
+    return c.json({
+      ok: true,
+      name,
+      port,
+      stage: manifest.stage ?? "sprouted",
+      message: `Imported mind: ${name} (port ${port})`,
+      ...gitWarning && { warning: gitWarning },
+      ...skillWarnings.length > 0 && { skillWarnings }
+    });
   } catch (err) {
-    if (existsSync12(dest)) rmSync3(dest, { recursive: true, force: true });
+    if (existsSync12(dest)) rmSync2(dest, { recursive: true, force: true });
     try {
       removeMind(name);
     } catch (cleanupErr) {
       logger_default.error(`Failed to clean up registry for ${name}`, logger_default.errorData(cleanupErr));
     }
-    rmSync3(tempDir, { recursive: true, force: true });
+    rmSync2(tempDir, { recursive: true, force: true });
     return c.json({ error: err instanceof Error ? err.message : "Failed to import mind" }, 500);
+  } finally {
+    rmSync2(composedDir, { recursive: true, force: true });
+  }
+}
+async function importHistoryFromArchive(name, tempDir) {
+  const historyJsonl = resolve16(tempDir, "history.jsonl");
+  if (!existsSync12(historyJsonl)) return;
+  try {
+    const db = await getDb();
+    const lines = readFileSync11(historyJsonl, "utf-8").trim().split("\n");
+    let imported = 0;
+    let failed = 0;
+    for (const line of lines) {
+      if (!line) continue;
+      try {
+        const row = JSON.parse(line);
+        if (!row.type) {
+          failed++;
+          continue;
+        }
+        await db.insert(mindHistory).values({
+          mind: name,
+          channel: row.channel ?? null,
+          session: row.session ?? null,
+          sender: row.sender ?? null,
+          message_id: row.message_id ?? null,
+          type: row.type,
+          content: row.content ?? null,
+          metadata: row.metadata ?? null,
+          created_at: row.created_at ?? (/* @__PURE__ */ new Date()).toISOString()
+        });
+        imported++;
+      } catch (lineErr) {
+        logger_default.warn("Failed to import history line", logger_default.errorData(lineErr));
+        failed++;
+      }
+    }
+    if (failed > 0) {
+      logger_default.warn(`History import: ${imported} imported, ${failed} failed`);
+    }
+  } catch (err) {
+    logger_default.error("Failed to open database for history import", logger_default.errorData(err));
+  }
+}
+function importSessionsFromArchive(dest, tempDir) {
+  const sessionsDir = resolve16(tempDir, "sessions");
+  if (!existsSync12(sessionsDir)) return;
+  try {
+    const destSessions = resolve16(dest, ".mind/sessions");
+    mkdirSync7(destSessions, { recursive: true });
+    for (const file of readdirSync5(sessionsDir)) {
+      cpSync(resolve16(sessionsDir, file), resolve16(destSessions, file));
+    }
+  } catch (err) {
+    logger_default.error("Failed to import sessions from archive", logger_default.errorData(err));
   }
 }
 var createMindSchema = z3.object({
@@ -3568,21 +4350,32 @@ var app11 = new Hono11().post("/", requireAdmin, zValidator3("json", createMindS
     copyTemplateToDir(composedDir, dest, name, manifest);
     applyInitFiles(dest);
     const { publicKeyPem } = generateIdentity(dest);
+    if (body.description) {
+      const seedConfig = readVoluteConfig(dest);
+      if (!seedConfig) throw new Error("Failed to read volute.json after identity generation");
+      seedConfig.description = body.description;
+      writeVoluteConfig(dest, seedConfig);
+    }
     if (body.model) {
       const configPath2 = resolve16(dest, "home/.config/config.json");
       const existing = existsSync12(configPath2) ? JSON.parse(readFileSync11(configPath2, "utf-8")) : {};
       existing.model = body.model;
-      writeFileSync9(configPath2, `${JSON.stringify(existing, null, 2)}
+      writeFileSync8(configPath2, `${JSON.stringify(existing, null, 2)}
 `);
     }
     const mindPrompts = await getMindPromptDefaults();
-    writeFileSync9(
+    writeFileSync8(
       resolve16(dest, "home/.config/prompts.json"),
       `${JSON.stringify(mindPrompts, null, 2)}
 `
     );
     const port = nextPort();
     addMind(name, port, body.stage, template);
+    try {
+      setMindTemplateHash(name, computeTemplateHash(template));
+    } catch (err) {
+      logger_default.warn(`failed to set template hash for ${name}`, logger_default.errorData(err));
+    }
     const homeDir = resolve16(dest, "home");
     ensureVoluteGroup();
     createMindUser(name, homeDir);
@@ -3596,7 +4389,7 @@ var app11 = new Hono11().post("/", requireAdmin, zValidator3("json", createMindS
       await initTemplateBranch(dest, composedDir, manifest, name, env);
     } catch (err) {
       logger_default.error(`git setup failed for ${name}`, logger_default.errorData(err));
-      rmSync3(resolve16(dest, ".git"), { recursive: true, force: true });
+      rmSync2(resolve16(dest, ".git"), { recursive: true, force: true });
       gitWarning = "Git setup failed \u2014 variants and upgrades won't be available until git is initialized.";
     }
     try {
@@ -3611,7 +4404,7 @@ The human who planted you described you as: "${body.description}"
 ` : "";
       const seedSoulRaw = body.seedSoul ?? await getPrompt("seed_soul", { name, description: descLine });
       const seedSoul = body.seedSoul ? substitute(seedSoulRaw, { name, description: descLine }) : seedSoulRaw;
-      writeFileSync9(resolve16(dest, "home/SOUL.md"), seedSoul);
+      writeFileSync8(resolve16(dest, "home/SOUL.md"), seedSoul);
     }
     const skillSet = body.skills ?? (body.stage === "seed" ? SEED_SKILLS : STANDARD_SKILLS);
     const skillWarnings = [];
@@ -3626,11 +4419,11 @@ The human who planted you described you as: "${body.description}"
     if (body.stage !== "seed") {
       const customSoul = await getPromptIfCustom("default_soul");
       if (customSoul) {
-        writeFileSync9(resolve16(dest, "home/SOUL.md"), customSoul.replace(/\{\{name\}\}/g, name));
+        writeFileSync8(resolve16(dest, "home/SOUL.md"), customSoul.replace(/\{\{name\}\}/g, name));
       }
       const customMemory = await getPromptIfCustom("default_memory");
       if (customMemory) {
-        writeFileSync9(resolve16(dest, "home/MEMORY.md"), customMemory);
+        writeFileSync8(resolve16(dest, "home/MEMORY.md"), customMemory);
       }
     }
     publishPublicKey(name, publicKeyPem).catch(
@@ -3646,14 +4439,14 @@ The human who planted you described you as: "${body.description}"
       ...skillWarnings.length > 0 && { skillWarnings }
     });
   } catch (err) {
-    if (existsSync12(dest)) rmSync3(dest, { recursive: true, force: true });
+    if (existsSync12(dest)) rmSync2(dest, { recursive: true, force: true });
     try {
       removeMind(name);
     } catch {
     }
     return c.json({ error: err instanceof Error ? err.message : "Failed to create mind" }, 500);
   } finally {
-    rmSync3(composedDir, { recursive: true, force: true });
+    rmSync2(composedDir, { recursive: true, force: true });
   }
 }).post("/import", requireAdmin, async (c) => {
   let body;
@@ -3699,31 +4492,36 @@ ${user.trimEnd()}
     copyTemplateToDir(composedDir, dest, name, manifest);
     applyInitFiles(dest);
     const { publicKeyPem: importPublicKey } = generateIdentity(dest);
-    writeFileSync9(resolve16(dest, "home/SOUL.md"), mergedSoul);
+    writeFileSync8(resolve16(dest, "home/SOUL.md"), mergedSoul);
     const wsMemoryPath = resolve16(wsDir, "MEMORY.md");
     const hasMemory = existsSync12(wsMemoryPath);
     if (hasMemory) {
       const existingMemory = readFileSync11(wsMemoryPath, "utf-8");
-      writeFileSync9(
+      writeFileSync8(
         resolve16(dest, "home/MEMORY.md"),
         `${existingMemory.trimEnd()}${mergedMemoryExtra}`
       );
     } else if (user) {
-      writeFileSync9(resolve16(dest, "home/MEMORY.md"), `${user.trimEnd()}
+      writeFileSync8(resolve16(dest, "home/MEMORY.md"), `${user.trimEnd()}
 `);
     }
     const wsMemoryDir = resolve16(wsDir, "memory");
     let dailyLogCount = 0;
     if (existsSync12(wsMemoryDir)) {
       const destMemoryDir = resolve16(dest, "home/memory");
-      const files = readdirSync6(wsMemoryDir).filter((f) => f.endsWith(".md"));
+      const files = readdirSync5(wsMemoryDir).filter((f) => f.endsWith(".md"));
       for (const file of files) {
-        cpSync2(resolve16(wsMemoryDir, file), resolve16(destMemoryDir, file));
+        cpSync(resolve16(wsMemoryDir, file), resolve16(destMemoryDir, file));
       }
       dailyLogCount = files.length;
     }
     const port = nextPort();
     addMind(name, port, void 0, template);
+    try {
+      setMindTemplateHash(name, computeTemplateHash(template));
+    } catch (err) {
+      logger_default.warn(`failed to set template hash for ${name}`, logger_default.errorData(err));
+    }
     const homeDir = resolve16(dest, "home");
     ensureVoluteGroup();
     createMindUser(name, homeDir);
@@ -3744,8 +4542,8 @@ ${user.trimEnd()}
       } else if (template === "claude") {
         const sessionId = convertSession({ sessionPath: sessionFile, projectDir: dest });
         const mindRuntimeDir = resolve16(dest, ".mind");
-        mkdirSync8(mindRuntimeDir, { recursive: true });
-        writeFileSync9(resolve16(mindRuntimeDir, "session.json"), JSON.stringify({ sessionId }));
+        mkdirSync7(mindRuntimeDir, { recursive: true });
+        writeFileSync8(resolve16(mindRuntimeDir, "session.json"), JSON.stringify({ sessionId }));
       }
     }
     importOpenClawConnectors(name, dest);
@@ -3760,14 +4558,14 @@ ${user.trimEnd()}
     );
     return c.json({ ok: true, name, port, message: `Imported mind: ${name} (port ${port})` });
   } catch (err) {
-    if (existsSync12(dest)) rmSync3(dest, { recursive: true, force: true });
+    if (existsSync12(dest)) rmSync2(dest, { recursive: true, force: true });
     try {
       removeMind(name);
     } catch {
     }
     return c.json({ error: err instanceof Error ? err.message : "Failed to import mind" }, 500);
   } finally {
-    rmSync3(composedDir, { recursive: true, force: true });
+    rmSync2(composedDir, { recursive: true, force: true });
   }
 }).get("/", async (c) => {
   const entries = readRegistry();
@@ -3783,12 +4581,11 @@ ${user.trimEnd()}
   }
   const minds = await Promise.all(
     entries.map(async (entry) => {
-      const { status, channels } = await getMindStatus(entry.name, entry.port);
+      const mindStatus = await getMindStatus(entry.name, entry.port);
       const hasPages = existsSync12(resolve16(mindDir(entry.name), "home", "pages"));
       return {
         ...entry,
-        status,
-        channels,
+        ...mindStatus,
         hasPages,
         lastActiveAt: lastActiveMap.get(entry.name) ?? null
       };
@@ -3804,7 +4601,7 @@ ${user.trimEnd()}
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   if (!existsSync12(mindDir(name))) return c.json({ error: "Mind directory missing" }, 404);
-  const { status, channels } = await getMindStatus(name, entry.port);
+  const mindStatus = await getMindStatus(name, entry.port);
   const variants = readVariants(name);
   const manager = getMindManager();
   const variantStatuses = await Promise.all(
@@ -3819,15 +4616,17 @@ ${user.trimEnd()}
     })
   );
   const hasPages = existsSync12(resolve16(mindDir(name), "home", "pages"));
-  return c.json({ ...entry, status, channels, variants: variantStatuses, hasPages });
+  return c.json({ ...entry, ...mindStatus, variants: variantStatuses, hasPages });
 }).post("/:name/start", requireAdmin, async (c) => {
   const name = c.req.param("name");
   const [baseName, variantName] = name.split("@", 2);
   const entry = findMind(baseName);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
+  let targetPort = entry.port;
   if (variantName) {
     const variant = findVariant(baseName, variantName);
     if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
+    targetPort = variant.port;
   } else {
     const dir = mindDir(baseName);
     if (!existsSync12(dir)) return c.json({ error: "Mind directory missing" }, 404);
@@ -3837,7 +4636,7 @@ ${user.trimEnd()}
   }
   try {
     await startMindFull(name);
-    return c.json({ ok: true });
+    return c.json({ ok: true, port: targetPort });
   } catch (err) {
     return c.json({ error: err instanceof Error ? err.message : "Failed to start mind" }, 500);
   }
@@ -3846,9 +4645,11 @@ ${user.trimEnd()}
   const [baseName, variantName] = name.split("@", 2);
   const entry = findMind(baseName);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
+  let targetPort = entry.port;
   if (variantName) {
     const variant = findVariant(baseName, variantName);
     if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
+    targetPort = variant.port;
   } else {
     const dir = mindDir(baseName);
     if (!existsSync12(dir)) return c.json({ error: "Mind directory missing" }, 404);
@@ -3944,7 +4745,7 @@ ${user.trimEnd()}
       }
     }
     await startMindFull(name);
-    return c.json({ ok: true });
+    return c.json({ ok: true, port: targetPort });
   } catch (err) {
     return c.json({ error: err instanceof Error ? err.message : "Failed to restart mind" }, 500);
   }
@@ -3996,10 +4797,10 @@ ${user.trimEnd()}
   await deleteMindUser2(name);
   const state = stateDir(name);
   if (existsSync12(state)) {
-    rmSync3(state, { recursive: true, force: true });
+    rmSync2(state, { recursive: true, force: true });
   }
   if (force && existsSync12(dir)) {
-    rmSync3(dir, { recursive: true, force: true });
+    rmSync2(dir, { recursive: true, force: true });
     deleteMindUser(name);
   }
   return c.json({ ok: true });
@@ -4094,7 +4895,7 @@ ${user.trimEnd()}
       await gitExec(["commit", "-m", "initial commit"], { cwd: dir, mindName, env });
       chownMindDir(dir, mindName);
     } catch (err) {
-      rmSync3(resolve16(dir, ".git"), { recursive: true, force: true });
+      rmSync2(resolve16(dir, ".git"), { recursive: true, force: true });
       return c.json(
         {
           error: `Git initialization failed: ${err instanceof Error ? err.message : String(err)}`
@@ -4121,7 +4922,7 @@ ${user.trimEnd()}
   await updateTemplateBranch(dir, template, mindName);
   const parentDir = resolve16(dir, ".variants");
   if (!existsSync12(parentDir)) {
-    mkdirSync8(parentDir, { recursive: true });
+    mkdirSync7(parentDir, { recursive: true });
   }
   await gitExec(["worktree", "add", "-b", UPGRADE_VARIANT, worktreeDir], { cwd: dir });
   const hasConflicts = await mergeTemplateBranch(worktreeDir);
@@ -4266,7 +5067,7 @@ ${user.trimEnd()}
       const countResult = await db.select({ count: sql2`count(*)` }).from(mindHistory).where(eq4(mindHistory.mind, baseName));
       const msgCount = countResult[0]?.count ?? 0;
       if (msgCount >= 10 && msgCount % 10 === 0) {
-        const nudge = "\n[You've been exploring for a while. Whenever you feel ready, write your SOUL.md and MEMORY.md, then run volute sprout.]";
+        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.]";
         if (typeof parsed.content === "string") {
           parsed.content = parsed.content + nudge;
         } else if (Array.isArray(parsed.content)) {
@@ -4459,7 +5260,7 @@ ${user.trimEnd()}
   const stream = new ReadableStream({
     start(controller) {
       const encoder = new TextEncoder();
-      const send = (data) => {
+      const send5 = (data) => {
         controller.enqueue(encoder.encode(`data: ${data}
 
 `));
@@ -4468,7 +5269,7 @@ ${user.trimEnd()}
         if (typeFilter && !typeFilter.includes(event.type)) return;
         if (sessionFilter && event.session !== sessionFilter) return;
         if (channelFilter && event.channel !== channelFilter) return;
-        send(JSON.stringify(event));
+        send5(JSON.stringify(event));
       });
       c.req.raw.signal.addEventListener("abort", () => {
         unsubscribe();
@@ -4528,6 +5329,12 @@ ${user.trimEnd()}
   const db = await getDb();
   const rows = await db.selectDistinct({ channel: mindHistory.channel }).from(mindHistory).where(eq4(mindHistory.mind, name));
   return c.json(rows.map((r) => r.channel));
+}).get("/:name/history/export", async (c) => {
+  const name = c.req.param("name");
+  if (!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));
+  return c.json(rows);
 }).get("/:name/history", async (c) => {
   const name = c.req.param("name");
   const channel = c.req.query("channel");
@@ -4552,8 +5359,8 @@ ${user.trimEnd()}
 var minds_default = app11;
 
 // src/web/api/pages.ts
-import { readFile as readFile2, stat } from "fs/promises";
-import { extname, resolve as resolve17 } from "path";
+import { readFile as readFile2, stat as stat2 } from "fs/promises";
+import { extname as extname2, resolve as resolve17 } from "path";
 import { Hono as Hono12 } from "hono";
 var MIME_TYPES = {
   ".html": "text/html",
@@ -4583,10 +5390,10 @@ var app12 = new Hono12().get("/:name/*", async (c) => {
   const wildcard = c.req.path.replace(`/pages/${name}`, "") || "/";
   const requestedPath = resolve17(pagesRoot, wildcard.slice(1));
   if (!requestedPath.startsWith(pagesRoot)) return c.text("Forbidden", 403);
-  let fileStat = await stat(requestedPath).catch(() => null);
+  let fileStat = await stat2(requestedPath).catch(() => null);
   if (fileStat?.isDirectory()) {
     const indexPath = resolve17(requestedPath, "index.html");
-    fileStat = await stat(indexPath).catch(() => null);
+    fileStat = await stat2(indexPath).catch(() => null);
     if (fileStat?.isFile()) {
       const body = await readFile2(indexPath);
       return c.body(body, 200, { "Content-Type": "text/html" });
@@ -4594,7 +5401,7 @@ var app12 = new Hono12().get("/:name/*", async (c) => {
     return c.text("Not found", 404);
   }
   if (fileStat?.isFile()) {
-    const ext = extname(requestedPath);
+    const ext = extname2(requestedPath);
     const mime = MIME_TYPES[ext] || "application/octet-stream";
     const body = await readFile2(requestedPath);
     return c.body(body, 200, { "Content-Type": mime });
@@ -4827,9 +5634,9 @@ var app15 = new Hono15().post("/:name/shared/merge", requireAdmin, async (c) =>
 var shared_default = app15;
 
 // src/web/api/skills.ts
-import { existsSync as existsSync13, mkdtempSync, readdirSync as readdirSync7, rmSync as rmSync4 } from "fs";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join4, resolve as resolve18 } from "path";
+import { existsSync as existsSync13, mkdtempSync, readdirSync as readdirSync6, rmSync as rmSync3 } from "fs";
+import { tmpdir } from "os";
+import { join as join3, resolve as resolve18 } from "path";
 import AdmZip from "adm-zip";
 import { Hono as Hono16 } from "hono";
 var app16 = new Hono16().get("/", async (c) => {
@@ -4839,7 +5646,7 @@ var app16 = new Hono16().get("/", async (c) => {
   const id = c.req.param("id");
   const skill = await getSharedSkill(id);
   if (!skill) return c.json({ error: "Skill not found" }, 404);
-  const dir = join4(sharedSkillsDir(), id);
+  const dir = join3(sharedSkillsDir(), id);
   const files = listFilesRecursive(dir);
   return c.json({ ...skill, files });
 }).post("/upload", requireAdmin, async (c) => {
@@ -4852,7 +5659,7 @@ var app16 = new Hono16().get("/", async (c) => {
     return c.json({ error: "Only .zip files are accepted" }, 400);
   }
   const buffer = Buffer.from(await file.arrayBuffer());
-  const tmpDir = mkdtempSync(join4(tmpdir2(), "volute-skill-upload-"));
+  const tmpDir = mkdtempSync(join3(tmpdir(), "volute-skill-upload-"));
   try {
     const zip = new AdmZip(buffer);
     for (const entry of zip.getEntries()) {
@@ -4863,13 +5670,13 @@ var app16 = new Hono16().get("/", async (c) => {
     }
     zip.extractAllTo(tmpDir, true);
     let skillDir = null;
-    if (existsSync13(join4(tmpDir, "SKILL.md"))) {
+    if (existsSync13(join3(tmpDir, "SKILL.md"))) {
       skillDir = tmpDir;
     } else {
-      const entries = readdirSync7(tmpDir, { withFileTypes: true }).filter((e) => e.isDirectory());
+      const entries = readdirSync6(tmpDir, { withFileTypes: true }).filter((e) => e.isDirectory());
       for (const entry of entries) {
-        if (existsSync13(join4(tmpDir, entry.name, "SKILL.md"))) {
-          skillDir = join4(tmpDir, entry.name);
+        if (existsSync13(join3(tmpDir, entry.name, "SKILL.md"))) {
+          skillDir = join3(tmpDir, entry.name);
           break;
         }
       }
@@ -4885,7 +5692,7 @@ var app16 = new Hono16().get("/", async (c) => {
     }
     throw e;
   } finally {
-    rmSync4(tmpDir, { recursive: true, force: true });
+    rmSync3(tmpDir, { recursive: true, force: true });
   }
 }).delete("/:id", requireAdmin, async (c) => {
   const id = c.req.param("id");
@@ -4987,13 +5794,13 @@ var app19 = new Hono19().get("/update", async (c) => {
 var update_default = app19;
 
 // src/web/api/variants.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
 import { resolve as resolve20 } from "path";
 import { Hono as Hono20 } 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 mkdirSync8, openSync, readFileSync as readFileSync12 } from "fs";
 import { resolve as resolve19 } from "path";
 function tsxBin(cwd) {
   return resolve19(cwd, "node_modules", ".bin", "tsx");
@@ -5032,7 +5839,7 @@ function spawnAttached(cwd, port) {
 }
 function spawnDetached(cwd, port, logDir) {
   const logsDir = logDir ?? resolve19(cwd, ".mind", "logs");
-  mkdirSync9(logsDir, { recursive: true });
+  mkdirSync8(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)], {
@@ -5117,6 +5924,16 @@ var app20 = new Hono20().get("/:name/variants", async (c) => {
       return { ...v, status: health.ok ? "running" : "dead" };
     })
   );
+  try {
+    const updated = results.map(({ status, ...v }) => ({
+      ...v,
+      running: status === "running"
+    }));
+    const changed = variants.some((v, i) => v.running !== updated[i].running);
+    if (changed) writeVariants(name, updated);
+  } catch (err) {
+    logger_default.warn(`failed to sync variant status for ${name}`, logger_default.errorData(err));
+  }
   return c.json(results);
 }).post("/:name/variants", requireAdmin, async (c) => {
   const mindName = c.req.param("name");
@@ -5139,7 +5956,7 @@ var app20 = new Hono20().get("/:name/variants", async (c) => {
   if (existsSync14(variantDir)) {
     return c.json({ error: `Variant directory already exists: ${variantDir}` }, 409);
   }
-  mkdirSync10(resolve20(projectRoot, ".variants"), { recursive: true });
+  mkdirSync9(resolve20(projectRoot, ".variants"), { recursive: true });
   try {
     await gitExec(["worktree", "add", "-b", variantName, variantDir], { cwd: projectRoot });
   } catch (e) {
@@ -5162,7 +5979,7 @@ var app20 = new Hono20().get("/:name/variants", async (c) => {
     return c.json({ error: `npm install failed: ${msg}` }, 500);
   }
   if (body.soul) {
-    writeFileSync10(resolve20(variantDir, "home/SOUL.md"), body.soul);
+    writeFileSync9(resolve20(variantDir, "home/SOUL.md"), body.soul);
   }
   const variantPort = body.port ?? nextPort();
   const variant = {
@@ -5268,6 +6085,16 @@ var app20 = new Hono20().get("/:name/variants", async (c) => {
   } catch {
   }
   removeVariant(mindName, variantName);
+  if (variantName === "upgrade") {
+    try {
+      const { computeTemplateHash: computeTemplateHash2 } = await import("./template-hash-BIMA4ILT.js");
+      const { setMindTemplateHash: setMindTemplateHash2 } = await import("./registry-D2BSQ2X5.js");
+      const tmpl = entry.template ?? "claude";
+      setMindTemplateHash2(mindName, computeTemplateHash2(tmpl));
+    } catch (err) {
+      console.error(`[daemon] failed to update template hash for ${mindName}:`, err);
+    }
+  }
   chownMindDir(projectRoot, mindName);
   try {
     if (isIsolationEnabled()) {
@@ -5420,7 +6247,7 @@ async function fanOutToMinds(opts) {
   const participantNames = participants.map((p) => p.username);
   const isDM = opts.isDM ?? participants.length === 2;
   const channelEntryType = opts.channelEntryType ?? (isDM ? "dm" : "group");
-  const { getMindManager: getMindManager2 } = await import("./mind-manager-3DMYKZPB.js");
+  const { getMindManager: getMindManager2 } = await import("./mind-manager-3V2NXX4I.js");
   const manager = getMindManager2();
   const runningMinds = mindParticipants.map((ap) => {
     const key = opts.targetName ? opts.targetName(ap.username) : ap.username;
@@ -5865,14 +6692,14 @@ async function startServer({
   hostname = "127.0.0.1"
 }) {
   let assetsDir = "";
-  let searchDir = dirname3(new URL(import.meta.url).pathname);
+  let searchDir = dirname2(new URL(import.meta.url).pathname);
   for (let i = 0; i < 5; i++) {
     const candidate = resolve21(searchDir, "dist", "web-assets");
     if (existsSync15(candidate)) {
       assetsDir = candidate;
       break;
     }
-    searchDir = dirname3(searchDir);
+    searchDir = dirname2(searchDir);
   }
   if (assetsDir) {
     app_default.get("*", async (c) => {
@@ -5880,15 +6707,15 @@ async function startServer({
       if (urlPath.startsWith("/api/")) return c.notFound();
       const filePath = resolve21(assetsDir, urlPath.slice(1));
       if (!filePath.startsWith(assetsDir)) return c.text("Forbidden", 403);
-      const s = await stat2(filePath).catch(() => null);
+      const s = await stat3(filePath).catch(() => null);
       if (s?.isFile()) {
-        const ext = extname2(filePath);
+        const ext = extname3(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 stat2(indexPath).catch(() => null);
+      const indexStat = await stat3(indexPath).catch(() => null);
       if (indexStat?.isFile()) {
         const body = await readFile3(indexPath, "utf-8");
         return c.html(body);
@@ -5930,7 +6757,7 @@ async function startDaemon(opts) {
   }
   const DAEMON_PID_PATH = resolve22(home, "daemon.pid");
   const DAEMON_JSON_PATH = resolve22(home, "daemon.json");
-  mkdirSync11(home, { recursive: true });
+  mkdirSync10(home, { recursive: true });
   migrateAgentsToMinds();
   try {
     await ensureSharedRepo();
@@ -5958,8 +6785,8 @@ async function startDaemon(opts) {
     }
     throw err;
   }
-  writeFileSync11(DAEMON_PID_PATH, myPid, { mode: 420 });
-  writeFileSync11(DAEMON_JSON_PATH, `${JSON.stringify({ port, hostname, token }, null, 2)}
+  writeFileSync10(DAEMON_PID_PATH, myPid, { mode: 420 });
+  writeFileSync10(DAEMON_JSON_PATH, `${JSON.stringify({ port, hostname, token }, null, 2)}
 `, {
     mode: 420
   });
@@ -6015,10 +6842,20 @@ async function startDaemon(opts) {
     });
     await Promise.all(workers);
   }
+  try {
+    const { backfillTemplateHashes, notifyVersionUpdate } = await import("./version-notify-TFS2U5CF.js");
+    backfillTemplateHashes();
+    notifyVersionUpdate().catch((err) => {
+      logger_default.warn("failed to send version update notifications", logger_default.errorData(err));
+    });
+  } catch (err) {
+    logger_default.warn("failed to initialize version notifications", logger_default.errorData(err));
+  }
   delivery.restoreFromDb().catch((err) => {
     logger_default.warn("failed to restore delivery queue", logger_default.errorData(err));
   });
-  cleanExpiredSessions().catch(() => {
+  cleanExpiredSessions().catch((err) => {
+    logger_default.warn("failed to clean expired sessions", logger_default.errorData(err));
   });
   logger_default.info(`running on ${hostname}:${port}, pid ${myPid}`);
   function cleanup() {
@@ -6041,19 +6878,33 @@ async function startDaemon(opts) {
     if (shuttingDown) return;
     shuttingDown = true;
     logger_default.info("shutting down...");
-    stopAllWatchers();
-    stopAll();
-    scheduler.stop();
-    scheduler.saveState();
-    mailPoller.stop();
-    tokenBudget.stop();
-    delivery.dispose();
-    await connectors.stopAll();
-    await manager.stopAll();
-    manager.clearCrashAttempts();
-    server.close();
-    cleanup();
-    process.exit(0);
+    const safe = (label, fn) => {
+      try {
+        const result = fn();
+        if (result instanceof Promise)
+          return result.catch((err) => logger_default.error(`shutdown: ${label} failed`, logger_default.errorData(err)));
+      } catch (err) {
+        logger_default.error(`shutdown: ${label} failed`, logger_default.errorData(err));
+      }
+    };
+    try {
+      safe("stopAllWatchers", stopAllWatchers);
+      safe("stopAllActivityTrackers", stopAll);
+      safe("scheduler.stop", () => scheduler.stop());
+      safe("scheduler.saveState", () => scheduler.saveState());
+      safe("mailPoller.stop", () => mailPoller.stop());
+      safe("tokenBudget.stop", () => tokenBudget.stop());
+      safe("delivery.dispose", () => delivery.dispose());
+      await safe("connectors.stopAll", () => connectors.stopAll());
+      await safe("manager.stopAll", () => manager.stopAll());
+      safe("clearCrashAttempts", () => manager.clearCrashAttempts());
+      safe("server.close", () => server.close());
+    } catch (err) {
+      logger_default.error("error during shutdown", logger_default.errorData(err));
+    } finally {
+      cleanup();
+      process.exit(0);
+    }
   }
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);