volute 0.17.0 → 0.19.0

package/dist/daemon.js

@@ -1,24 +1,62 @@
 #!/usr/bin/env node
 import {
-  applyInitFiles,
-  composeTemplate,
-  copyTemplateToDir,
-  findTemplatesRoot,
-  listFiles
-} from "./chunk-PO5Q2AYN.js";
+  SEED_SKILLS,
+  STANDARD_SKILLS,
+  getSharedSkill,
+  importSkillFromDir,
+  installSkill,
+  listFilesRecursive,
+  listMindSkills,
+  listSharedSkills,
+  publishSkill,
+  removeSharedSkill,
+  sharedSkillsDir,
+  syncBuiltinSkills,
+  uninstallSkill,
+  updateSkill
+} from "./chunk-OTWLI7F4.js";
+import {
+  addSharedWorktree,
+  ensureSharedRepo,
+  removeSharedWorktree,
+  sharedLog,
+  sharedMerge,
+  sharedPull,
+  sharedStatus
+} from "./chunk-4KPUF5JD.js";
 import {
   readSystemsConfig
-} from "./chunk-37X7ECMF.js";
+} from "./chunk-FCDU5BFX.js";
+import {
+  deliverMessage,
+  extractTextContent,
+  getDeliveryManager,
+  getTypingMap,
+  initDeliveryManager
+} from "./chunk-FGV2H4TX.js";
 import {
+  PROMPT_DEFAULTS,
+  PROMPT_KEYS,
+  RestartTracker,
   RotatingLog,
   clearJsonMap,
   getMindManager,
+  getMindPromptDefaults,
+  getPrompt,
+  getPromptIfCustom,
   initMindManager,
   loadJsonMap,
+  saveJsonMap,
+  substitute
+} from "./chunk-2TJGRJ4O.js";
+import {
   logBuffer,
-  logger_default,
-  saveJsonMap
-} from "./chunk-CE7WMOVW.js";
+  logger_default
+} from "./chunk-YUIHSKR6.js";
+import {
+  CHANNELS,
+  getChannelDriver
+} from "./chunk-UJ6GHNR7.js";
 import {
   findOpenClawSession,
   importOpenClawConnectors,
@@ -26,23 +64,32 @@ import {
   parseNameFromIdentity,
   readVoluteConfig,
   writeVoluteConfig
-} from "./chunk-GSPWIM5E.js";
+} from "./chunk-EMQSAY3B.js";
 import {
   loadMergedEnv,
   mindEnvPath,
   readEnv,
   sharedEnvPath,
   writeEnv
-} from "./chunk-OYSZNX5I.js";
+} from "./chunk-VDWCHYTS.js";
 import {
-  CHANNELS,
-  getChannelDriver
-} from "./chunk-MIJIAGGG.js";
+  getDb
+} from "./chunk-Z524RFCJ.js";
+import {
+  conversationParticipants,
+  conversations,
+  messages,
+  mindHistory,
+  sessions,
+  systemPrompts,
+  users
+} from "./chunk-VQWDC6UK.js";
+import "./chunk-D424ZQGI.js";
 import {
   exec,
   gitExec,
   resolveVoluteBin
-} from "./chunk-2Y77MCFG.js";
+} from "./chunk-DYZGP3EW.js";
 import {
   chownMindDir,
   createMindUser,
@@ -50,17 +97,16 @@ import {
   ensureVoluteGroup,
   isIsolationEnabled,
   wrapForIsolation
-} from "./chunk-ZCEYUUID.js";
+} from "./chunk-OGXOMR65.js";
 import {
   checkForUpdate,
   checkForUpdateCached,
   getCurrentVersion
-} from "./chunk-MVSXRMJJ.js";
-import "./chunk-D424ZQGI.js";
+} from "./chunk-SCUDS4US.js";
 import {
   buildVoluteSlug,
   writeChannelEntry
-} from "./chunk-3FC42ZBM.js";
+} from "./chunk-RHEGSQFJ.js";
 import {
   addMind,
   addVariant,
@@ -70,6 +116,7 @@ import {
   findMind,
   findVariant,
   getAllRunningVariants,
+  initRegistryCache,
   mindDir,
   nextPort,
   readRegistry,
@@ -84,16 +131,14 @@ import {
   validateBranchName,
   validateMindName,
   voluteHome
-} from "./chunk-M77QBTEH.js";
-import {
-  __export
-} from "./chunk-K3NQKI34.js";
+} from "./chunk-EBGCNDMM.js";
+import "./chunk-K3NQKI34.js";
 
 // src/daemon.ts
 import { randomBytes } from "crypto";
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync9, unlinkSync as unlinkSync2, writeFileSync as writeFileSync7 } from "fs";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync11, unlinkSync as unlinkSync2, writeFileSync as writeFileSync10 } from "fs";
 import { homedir as homedir2 } from "os";
-import { resolve as resolve17 } from "path";
+import { resolve as resolve19 } from "path";
 import { format } from "util";
 
 // src/lib/connector-manager.ts
@@ -184,16 +229,12 @@ function searchUpwards(...segments) {
   }
   return null;
 }
-var MAX_RESTART_ATTEMPTS = 5;
-var BASE_RESTART_DELAY = 3e3;
-var MAX_RESTART_DELAY = 6e4;
 var ConnectorManager = class {
   connectors = /* @__PURE__ */ new Map();
   stopping = /* @__PURE__ */ new Set();
   // "mind:type" keys currently being explicitly stopped
   shuttingDown = false;
-  restartAttempts = /* @__PURE__ */ new Map();
-  // "mind:type" -> count
+  restartTracker = new RestartTracker();
   async startConnectors(mindName, mindDir2, mindPort, daemonPort) {
     const config = readVoluteConfig(mindDir2) ?? {};
     const types = config.connectors ?? [];
@@ -306,7 +347,7 @@ var ConnectorManager = class {
     }
     this.connectors.get(mindName).set(type, { child, type });
     const stopKey = `${mindName}:${type}`;
-    this.restartAttempts.delete(stopKey);
+    this.restartTracker.reset(stopKey);
     child.on("exit", (code) => {
       const mindMap = this.connectors.get(mindName);
       if (mindMap?.get(type)?.child === child) {
@@ -316,15 +357,13 @@ var ConnectorManager = class {
       if (this.stopping.has(stopKey)) return;
       clog.error(`connector ${type} for ${mindName} exited with code ${code}`);
       if (lastStderr) clog.warn(`connector ${type} last output: ${lastStderr}`);
-      const attempts = this.restartAttempts.get(stopKey) ?? 0;
-      if (attempts >= MAX_RESTART_ATTEMPTS) {
-        clog.error(`connector ${type} for ${mindName} crashed ${attempts} times \u2014 giving up`);
+      const { shouldRestart, delay, attempt } = this.restartTracker.recordCrash(stopKey);
+      if (!shouldRestart) {
+        clog.error(`connector ${type} for ${mindName} crashed ${attempt} times \u2014 giving up`);
         return;
       }
-      const delay = Math.min(BASE_RESTART_DELAY * 2 ** attempts, MAX_RESTART_DELAY);
-      this.restartAttempts.set(stopKey, attempts + 1);
       clog.info(
-        `restarting connector ${type} for ${mindName} \u2014 attempt ${attempts + 1}/${MAX_RESTART_ATTEMPTS}, in ${delay}ms`
+        `restarting connector ${type} for ${mindName} \u2014 attempt ${attempt}/${this.restartTracker.maxRestartAttempts}, in ${delay}ms`
       );
       setTimeout(() => {
         if (this.shuttingDown || this.stopping.has(stopKey)) return;
@@ -343,23 +382,23 @@ var ConnectorManager = class {
     const stopKey = `${mindName}:${type}`;
     this.stopping.add(stopKey);
     mindMap.delete(type);
-    await new Promise((resolve18) => {
-      tracked.child.on("exit", () => resolve18());
+    await new Promise((resolve20) => {
+      tracked.child.on("exit", () => resolve20());
       try {
         tracked.child.kill("SIGTERM");
       } catch {
-        resolve18();
+        resolve20();
       }
       setTimeout(() => {
         try {
           tracked.child.kill("SIGKILL");
         } catch {
         }
-        resolve18();
+        resolve20();
       }, 5e3);
     });
     this.stopping.delete(stopKey);
-    this.restartAttempts.delete(stopKey);
+    this.restartTracker.reset(stopKey);
     try {
       this.removeConnectorPid(mindName, type);
     } catch (err) {
@@ -431,7 +470,8 @@ function initConnectorManager() {
   return instance;
 }
 function getConnectorManager() {
-  if (!instance) instance = new ConnectorManager();
+  if (!instance)
+    throw new Error("ConnectorManager not initialized \u2014 call initConnectorManager() first");
   return instance;
 }
 
@@ -455,15 +495,13 @@ var INITIAL_RECONNECT_MS = 1e3;
 var MAX_RECONNECT_MS = 6e4;
 var MailPoller = class {
   ws = null;
-  daemonPort = null;
-  daemonToken = null;
   running = false;
   pingTimer = null;
   reconnectTimer = null;
   reconnectDelay = INITIAL_RECONNECT_MS;
   reconnectAttempts = 0;
   disconnectedAt = null;
-  start(daemonPort, daemonToken) {
+  start() {
     if (this.running) {
       mlog.warn("already running \u2014 ignoring duplicate start");
       return;
@@ -473,8 +511,6 @@ var MailPoller = class {
       mlog.info("no systems config \u2014 mail disabled");
       return;
     }
-    this.daemonPort = daemonPort ?? null;
-    this.daemonToken = daemonToken ?? null;
     this.running = true;
     this.connect();
   }
@@ -630,51 +666,29 @@ var MailPoller = class {
       mlog.warn(`skipping delivery to ${mind}: ${!entry ? "not found" : "not running"}`);
       return;
     }
-    const channel = `mail:${email.from.address}`;
-    const sender = email.from.name || email.from.address;
-    const text2 = formatEmailContent(email);
-    const body = JSON.stringify({
-      content: [{ type: "text", text: text2 }],
-      channel,
-      sender,
-      platform: "Email",
-      isDM: true
-    });
-    if (!this.daemonPort || !this.daemonToken) {
-      mlog.warn(`cannot deliver to ${mind}: daemon port/token not set`);
-      return;
-    }
-    const daemonUrl = `http://${daemonLoopback()}:${this.daemonPort}`;
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 12e4);
+    const text = formatEmailContent(email);
     try {
-      const res = await fetch(`${daemonUrl}/api/minds/${encodeURIComponent(mind)}/message`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${this.daemonToken}`,
-          Origin: daemonUrl
-        },
-        body,
-        signal: controller.signal
-      });
-      if (!res.ok) {
-        mlog.warn(`deliver to ${mind} got HTTP ${res.status}`);
-      } else {
-        mlog.info(`delivered email from ${email.from.address} to ${mind}`);
-      }
-      await res.text().catch(() => {
+      await deliverMessage(mind, {
+        content: [{ type: "text", text }],
+        channel: `mail:${email.from.address}`,
+        sender: email.from.name || email.from.address,
+        platform: "Email",
+        isDM: true
       });
+      mlog.info(`delivered email from ${email.from.address} to ${mind}`);
     } catch (err) {
       mlog.warn(`failed to deliver to ${mind}`, logger_default.errorData(err));
-    } finally {
-      clearTimeout(timeout);
     }
   }
 };
 var instance2 = null;
+function initMailPoller() {
+  if (instance2) throw new Error("MailPoller already initialized");
+  instance2 = new MailPoller();
+  return instance2;
+}
 function getMailPoller() {
-  if (!instance2) instance2 = new MailPoller();
+  if (!instance2) throw new Error("MailPoller not initialized \u2014 call initMailPoller() first");
   return instance2;
 }
 async function ensureMailAddress(mindName) {
@@ -833,10 +847,20 @@ function migrateProfileScript() {
 }
 
 // src/lib/migrate-state.ts
-import { copyFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readdirSync } from "fs";
+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), ".volute");
+  const src = resolve4(mindDir(name), ".mind");
   if (!existsSync4(src)) return;
   const dest = stateDir(name);
   mkdirSync2(dest, { recursive: true });
@@ -870,14 +894,10 @@ var Scheduler = class {
   interval = null;
   lastFired = /* @__PURE__ */ new Map();
   // "mind:scheduleId" → epoch minute
-  daemonPort = null;
-  daemonToken = null;
   get statePath() {
     return resolve5(voluteHome(), "scheduler-state.json");
   }
-  start(daemonPort, daemonToken) {
-    this.daemonPort = daemonPort ?? null;
-    this.daemonToken = daemonToken ?? null;
+  start() {
     this.loadState();
     this.interval = setInterval(() => this.tick(), 6e4);
   }
@@ -908,9 +928,6 @@ var Scheduler = class {
     this.schedules.delete(mindName);
   }
   tick() {
-    for (const mind of this.schedules.keys()) {
-      this.loadSchedules(mind);
-    }
     const now = /* @__PURE__ */ new Date();
     for (const [mind, schedules] of this.schedules) {
       for (const schedule of schedules) {
@@ -941,69 +958,39 @@ var Scheduler = class {
     }
   }
   async fire(mindName, schedule) {
-    const entry = findMind(mindName);
-    if (!entry) return;
-    const body = JSON.stringify({
-      content: [{ type: "text", text: schedule.message }],
-      channel: "system:scheduler",
-      sender: schedule.id
-    });
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 12e4);
     try {
-      let res;
-      if (this.daemonPort && this.daemonToken) {
-        const daemonUrl = `http://${daemonLoopback()}:${this.daemonPort}`;
-        res = await fetch(`${daemonUrl}/api/minds/${encodeURIComponent(mindName)}/message`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${this.daemonToken}`,
-            Origin: daemonUrl
-          },
-          body,
-          signal: controller.signal
-        });
-      } else {
-        res = await fetch(`http://127.0.0.1:${entry.port}/message`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body,
-          signal: controller.signal
-        });
-      }
-      if (!res.ok) {
-        slog.warn(`"${schedule.id}" for ${mindName} got HTTP ${res.status}`);
-      } else {
-        slog.info(`fired "${schedule.id}" for ${mindName}`);
-      }
-      await res.text().catch(() => {
+      await deliverMessage(mindName, {
+        content: [{ type: "text", text: schedule.message }],
+        channel: "system:scheduler",
+        sender: schedule.id
       });
+      slog.info(`fired "${schedule.id}" for ${mindName}`);
     } catch (err) {
       slog.warn(`failed to fire "${schedule.id}" for ${mindName}`, logger_default.errorData(err));
-    } finally {
-      clearTimeout(timeout);
     }
   }
 };
 var instance3 = null;
+function initScheduler() {
+  if (instance3) throw new Error("Scheduler already initialized");
+  instance3 = new Scheduler();
+  return instance3;
+}
 function getScheduler() {
-  if (!instance3) instance3 = new Scheduler();
+  if (!instance3) throw new Error("Scheduler not initialized \u2014 call initScheduler() first");
   return instance3;
 }
 
 // src/lib/token-budget.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolve6 } 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;
-  daemonPort = null;
-  daemonToken = null;
-  start(daemonPort, daemonToken) {
-    this.daemonPort = daemonPort ?? null;
-    this.daemonToken = daemonToken ?? null;
+  start() {
     this.interval = setInterval(() => this.tick(), 6e4);
   }
   stop() {
@@ -1017,14 +1004,21 @@ var TokenBudget = class {
       existing.tokenLimit = tokenLimit;
       existing.periodMinutes = periodMinutes;
     } else {
-      this.budgets.set(mind, {
-        tokensUsed: 0,
-        periodStart: Date.now(),
-        periodMinutes,
-        tokenLimit,
-        queue: [],
-        warningInjected: false
-      });
+      const persisted = this.loadBudgetState(mind);
+      if (persisted) {
+        persisted.tokenLimit = tokenLimit;
+        persisted.periodMinutes = periodMinutes;
+        this.budgets.set(mind, persisted);
+      } else {
+        this.budgets.set(mind, {
+          tokensUsed: 0,
+          periodStart: Date.now(),
+          periodMinutes,
+          tokenLimit,
+          queue: [],
+          warningInjected: false
+        });
+      }
     }
   }
   removeBudget(mind) {
@@ -1034,6 +1028,7 @@ var TokenBudget = class {
     const state = this.budgets.get(mind);
     if (!state) return;
     state.tokensUsed += inputTokens + outputTokens;
+    this.saveBudgetState(mind, state);
   }
   /** Returns current budget status. Does not mutate state — call acknowledgeWarning() after delivering a warning. */
   checkBudget(mind) {
@@ -1084,6 +1079,7 @@ var TokenBudget = class {
         state.tokensUsed = 0;
         state.periodStart = now;
         state.warningInjected = false;
+        this.saveBudgetState(mind, state);
         const queued = this.drain(mind);
         if (queued.length > 0) {
           this.replay(mind, queued).catch((err) => {
@@ -1093,68 +1089,117 @@ var TokenBudget = class {
       }
     }
   }
-  async replay(mindName, messages2) {
-    if (!this.daemonPort || !this.daemonToken) {
-      tlog.warn(
-        `cannot replay ${messages2.length} message(s) for ${mindName}: daemon not configured`
-      );
-      const state = this.budgets.get(mindName);
-      if (state) state.queue.push(...messages2);
-      return;
+  budgetStatePath(mind) {
+    return resolve6(stateDir(mind), "budget.json");
+  }
+  saveBudgetState(mind, state) {
+    try {
+      const dir = stateDir(mind);
+      mkdirSync3(dir, { recursive: true });
+      const data = {
+        periodStart: state.periodStart,
+        tokensUsed: state.tokensUsed,
+        warningInjected: state.warningInjected,
+        queue: state.queue
+      };
+      writeFileSync3(this.budgetStatePath(mind), `${JSON.stringify(data)}
+`);
+    } catch (err) {
+      tlog.warn(`failed to save budget state for ${mind}`, logger_default.errorData(err));
+    }
+  }
+  loadBudgetState(mind) {
+    try {
+      const path = this.budgetStatePath(mind);
+      if (!existsSync5(path)) return null;
+      const data = JSON.parse(readFileSync4(path, "utf-8"));
+      if (typeof data.periodStart !== "number" || typeof data.tokensUsed !== "number") return null;
+      return {
+        periodStart: data.periodStart,
+        tokensUsed: data.tokensUsed,
+        warningInjected: data.warningInjected ?? false,
+        queue: Array.isArray(data.queue) ? data.queue : [],
+        periodMinutes: 0,
+        // will be overwritten by caller
+        tokenLimit: 0
+        // will be overwritten by caller
+      };
+    } catch (err) {
+      tlog.warn(`failed to load budget state for ${mind}`, logger_default.errorData(err));
+      return null;
     }
+  }
+  async replay(mindName, messages2) {
     const summary = messages2.map((m) => {
       const from = m.sender ? `[${m.sender}]` : "";
       const ch = m.channel ? `(${m.channel})` : "";
       return `${from}${ch} ${m.textContent}`;
     }).join("\n");
-    const body = JSON.stringify({
-      content: [
-        {
-          type: "text",
-          text: `[Budget replay] ${messages2.length} queued message(s) from the previous budget period:
+    try {
+      await deliverMessage(mindName, {
+        content: [
+          {
+            type: "text",
+            text: `[Budget replay] ${messages2.length} queued message(s) from the previous budget period:
 
 ${summary}`
-        }
-      ],
-      channel: "system:budget-replay",
-      sender: "system"
-    });
-    const daemonUrl = `http://${daemonLoopback()}:${this.daemonPort}`;
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 12e4);
-    try {
-      const res = await fetch(`${daemonUrl}/api/minds/${encodeURIComponent(mindName)}/message`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${this.daemonToken}`,
-          Origin: daemonUrl
-        },
-        body,
-        signal: controller.signal
-      });
-      if (!res.ok) {
-        tlog.warn(`replay for ${mindName} got HTTP ${res.status}`);
-      } else {
-        tlog.info(`replayed ${messages2.length} queued message(s) for ${mindName}`);
-      }
-      await res.text().catch(() => {
+          }
+        ],
+        channel: "system:budget-replay",
+        sender: "system"
       });
+      tlog.info(`replayed ${messages2.length} queued message(s) for ${mindName}`);
     } catch (err) {
       tlog.warn(`failed to replay for ${mindName}`, logger_default.errorData(err));
       const state = this.budgets.get(mindName);
       if (state) state.queue.push(...messages2);
-    } finally {
-      clearTimeout(timeout);
     }
   }
 };
 var instance4 = null;
+function initTokenBudget() {
+  if (instance4) throw new Error("TokenBudget already initialized");
+  instance4 = new TokenBudget();
+  return instance4;
+}
 function getTokenBudget() {
-  if (!instance4) instance4 = new TokenBudget();
+  if (!instance4) throw new Error("TokenBudget not initialized \u2014 call initTokenBudget() first");
   return instance4;
 }
 
+// src/lib/mind-service.ts
+async function startMindFull(name) {
+  const [baseName, variantName] = name.split("@", 2);
+  await getMindManager().startMind(name);
+  if (variantName) return;
+  const entry = findMind(baseName);
+  if (!entry || entry.stage === "seed") return;
+  const dir = mindDir(baseName);
+  const daemonPort = process.env.VOLUTE_DAEMON_PORT ? parseInt(process.env.VOLUTE_DAEMON_PORT, 10) : void 0;
+  await getConnectorManager().startConnectors(baseName, dir, entry.port, daemonPort);
+  getScheduler().loadSchedules(baseName);
+  ensureMailAddress(baseName).catch(
+    (err) => logger_default.error(`failed to ensure mail address for ${baseName}`, logger_default.errorData(err))
+  );
+  const config = readVoluteConfig(dir);
+  if (config?.tokenBudget) {
+    getTokenBudget().setBudget(
+      baseName,
+      config.tokenBudget,
+      config.tokenBudgetPeriodMinutes ?? DEFAULT_BUDGET_PERIOD_MINUTES
+    );
+  }
+}
+async function stopMindFull(name) {
+  const [baseName, variantName] = name.split("@", 2);
+  if (!variantName) {
+    await getConnectorManager().stopConnectors(baseName);
+    getScheduler().unloadSchedules(baseName);
+    getTokenBudget().removeBudget(baseName);
+  }
+  await getMindManager().stopMind(name);
+}
+
 // src/web/middleware/auth.ts
 import { timingSafeEqual } from "crypto";
 import { eq as eq2, lt } from "drizzle-orm";
@@ -1164,129 +1209,12 @@ import { createMiddleware } from "hono/factory";
 // src/lib/auth.ts
 import { compareSync, hashSync } from "bcryptjs";
 import { and, count, eq } from "drizzle-orm";
-
-// src/lib/db.ts
-import { chmodSync, existsSync as existsSync5 } from "fs";
-import { dirname as dirname2, resolve as resolve6 } from "path";
-import { fileURLToPath } from "url";
-import { drizzle } from "drizzle-orm/libsql";
-import { migrate } from "drizzle-orm/libsql/migrator";
-
-// src/lib/schema.ts
-var schema_exports = {};
-__export(schema_exports, {
-  conversationParticipants: () => conversationParticipants,
-  conversations: () => conversations,
-  messages: () => messages,
-  mindHistory: () => mindHistory,
-  sessions: () => sessions,
-  users: () => users
-});
-import { sql } from "drizzle-orm";
-import { index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
-var users = sqliteTable("users", {
-  id: integer("id").primaryKey({ autoIncrement: true }),
-  username: text("username").unique().notNull(),
-  password_hash: text("password_hash").notNull(),
-  role: text("role").notNull().default("pending"),
-  user_type: text("user_type").notNull().default("human"),
-  created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
-});
-var conversations = sqliteTable(
-  "conversations",
-  {
-    id: text("id").primaryKey(),
-    mind_name: text("mind_name").notNull(),
-    channel: text("channel").notNull(),
-    user_id: integer("user_id").references(() => users.id),
-    title: text("title"),
-    created_at: text("created_at").notNull().default(sql`(datetime('now'))`),
-    updated_at: text("updated_at").notNull().default(sql`(datetime('now'))`)
-  },
-  (table) => [
-    index("idx_conversations_mind_name").on(table.mind_name),
-    index("idx_conversations_user_id").on(table.user_id),
-    index("idx_conversations_updated_at").on(table.updated_at)
-  ]
-);
-var mindHistory = sqliteTable(
-  "mind_history",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    mind: text("mind").notNull(),
-    channel: text("channel"),
-    session: text("session"),
-    sender: text("sender"),
-    message_id: text("message_id"),
-    type: text("type").notNull(),
-    content: text("content"),
-    metadata: text("metadata"),
-    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
-  },
-  (table) => [
-    index("idx_mind_history_mind").on(table.mind),
-    index("idx_mind_history_mind_channel").on(table.mind, table.channel),
-    index("idx_mind_history_mind_type").on(table.mind, table.type)
-  ]
-);
-var conversationParticipants = sqliteTable(
-  "conversation_participants",
-  {
-    conversation_id: text("conversation_id").notNull().references(() => conversations.id, { onDelete: "cascade" }),
-    user_id: integer("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    role: text("role").notNull().default("member"),
-    joined_at: text("joined_at").notNull().default(sql`(datetime('now'))`)
-  },
-  (table) => [
-    uniqueIndex("idx_cp_unique").on(table.conversation_id, table.user_id),
-    index("idx_cp_user_id").on(table.user_id)
-  ]
-);
-var sessions = sqliteTable("sessions", {
-  id: text("id").primaryKey(),
-  userId: integer("user_id").references(() => users.id, { onDelete: "cascade" }).notNull(),
-  createdAt: integer("created_at").notNull()
-});
-var messages = sqliteTable(
-  "messages",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    conversation_id: text("conversation_id").notNull().references(() => conversations.id, { onDelete: "cascade" }),
-    role: text("role").notNull(),
-    sender_name: text("sender_name"),
-    content: text("content").notNull(),
-    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
-  },
-  (table) => [index("idx_messages_conversation_id").on(table.conversation_id)]
-);
-
-// src/lib/db.ts
-var __dirname = dirname2(fileURLToPath(import.meta.url));
-var migrationsFolder = existsSync5(resolve6(__dirname, "../drizzle")) ? resolve6(__dirname, "../drizzle") : resolve6(__dirname, "../../drizzle");
-var db = null;
-async function getDb() {
-  if (db) return db;
-  const dbPath = process.env.VOLUTE_DB_PATH || resolve6(voluteHome(), "volute.db");
-  db = drizzle({ connection: { url: `file:${dbPath}` }, schema: schema_exports });
-  await migrate(db, { migrationsFolder });
-  try {
-    chmodSync(dbPath, 384);
-  } catch (err) {
-    console.error(
-      `[volute] WARNING: Failed to restrict database file permissions on ${dbPath}:`,
-      err
-    );
-  }
-  return db;
-}
-
-// src/lib/auth.ts
 async function createUser(username, password) {
-  const db2 = await getDb();
+  const db = await getDb();
   const hash = hashSync(password, 10);
-  const [{ value }] = await db2.select({ value: count() }).from(users).where(eq(users.user_type, "human"));
+  const [{ value }] = await db.select({ value: count() }).from(users).where(eq(users.user_type, "brain"));
   const role = value === 0 ? "admin" : "pending";
-  const [result] = await db2.insert(users).values({ username, password_hash: hash, role }).returning({
+  const [result] = await db.insert(users).values({ username, password_hash: hash, role }).returning({
     id: users.id,
     username: users.username,
     role: users.role,
@@ -1296,8 +1224,8 @@ async function createUser(username, password) {
   return result;
 }
 async function verifyUser(username, password) {
-  const db2 = await getDb();
-  const row = await db2.select().from(users).where(eq(users.username, username)).get();
+  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;
@@ -1305,8 +1233,8 @@ async function verifyUser(username, password) {
   return user;
 }
 async function getUser(id) {
-  const db2 = await getDb();
-  const row = await db2.select({
+  const db = await getDb();
+  const row = await db.select({
     id: users.id,
     username: users.username,
     role: users.role,
@@ -1316,8 +1244,8 @@ async function getUser(id) {
   return row ?? null;
 }
 async function getUserByUsername(username) {
-  const db2 = await getDb();
-  const row = await db2.select({
+  const db = await getDb();
+  const row = await db.select({
     id: users.id,
     username: users.username,
     role: users.role,
@@ -1327,8 +1255,8 @@ async function getUserByUsername(username) {
   return row ?? null;
 }
 async function listUsers() {
-  const db2 = await getDb();
-  return db2.select({
+  const db = await getDb();
+  return db.select({
     id: users.id,
     username: users.username,
     role: users.role,
@@ -1337,8 +1265,8 @@ async function listUsers() {
   }).from(users).orderBy(users.created_at).all();
 }
 async function listPendingUsers() {
-  const db2 = await getDb();
-  return db2.select({
+  const db = await getDb();
+  return db.select({
     id: users.id,
     username: users.username,
     role: users.role,
@@ -1347,8 +1275,8 @@ async function listPendingUsers() {
   }).from(users).where(eq(users.role, "pending")).orderBy(users.created_at).all();
 }
 async function listUsersByType(userType) {
-  const db2 = await getDb();
-  return db2.select({
+  const db = await getDb();
+  return db.select({
     id: users.id,
     username: users.username,
     role: users.role,
@@ -1357,8 +1285,8 @@ async function listUsersByType(userType) {
   }).from(users).where(eq(users.user_type, userType)).orderBy(users.created_at).all();
 }
 async function getOrCreateMindUser(mindName) {
-  const db2 = await getDb();
-  const existing = await db2.select({
+  const db = await getDb();
+  const existing = await db.select({
     id: users.id,
     username: users.username,
     role: users.role,
@@ -1367,7 +1295,7 @@ async function getOrCreateMindUser(mindName) {
   }).from(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind"))).get();
   if (existing) return existing;
   try {
-    const [result] = await db2.insert(users).values({
+    const [result] = await db.insert(users).values({
       username: mindName,
       password_hash: "!mind",
       role: "mind",
@@ -1382,7 +1310,7 @@ async function getOrCreateMindUser(mindName) {
     return result;
   } catch (err) {
     if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
-      const retried = await db2.select({
+      const retried = await db.select({
         id: users.id,
         username: users.username,
         role: users.role,
@@ -1395,12 +1323,21 @@ async function getOrCreateMindUser(mindName) {
   }
 }
 async function deleteMindUser2(mindName) {
-  const db2 = await getDb();
-  await db2.delete(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind")));
+  const db = await getDb();
+  await db.delete(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind")));
+}
+async function changePassword(userId, currentPassword, newPassword) {
+  const db = await getDb();
+  const row = await db.select().from(users).where(eq(users.id, userId)).get();
+  if (!row) return false;
+  if (!compareSync(currentPassword, row.password_hash)) return false;
+  const hash = hashSync(newPassword, 10);
+  await db.update(users).set({ password_hash: hash }).where(eq(users.id, userId));
+  return true;
 }
 async function approveUser(id) {
-  const db2 = await getDb();
-  await db2.update(users).set({ role: "user" }).where(and(eq(users.id, id), eq(users.role, "pending")));
+  const db = await getDb();
+  await db.update(users).set({ role: "user" }).where(and(eq(users.id, id), eq(users.role, "pending")));
 }
 
 // src/web/middleware/auth.ts
@@ -1410,30 +1347,33 @@ function isValidDaemonToken(token) {
   return timingSafeEqual(Buffer.from(token), Buffer.from(expected));
 }
 var SESSION_MAX_AGE = 864e5;
+var SESSION_CACHE_TTL = 5 * 60 * 1e3;
+var sessionCache = /* @__PURE__ */ new Map();
 async function createSession(userId) {
-  const db2 = await getDb();
+  const db = await getDb();
   const sessionId = crypto.randomUUID();
-  await db2.insert(sessions).values({ id: sessionId, userId, createdAt: Date.now() });
+  await db.insert(sessions).values({ id: sessionId, userId, createdAt: Date.now() });
   return sessionId;
 }
 async function deleteSession(sessionId) {
-  const db2 = await getDb();
-  await db2.delete(sessions).where(eq2(sessions.id, sessionId));
+  sessionCache.delete(sessionId);
+  const db = await getDb();
+  await db.delete(sessions).where(eq2(sessions.id, sessionId));
 }
 async function getSessionUserId(sessionId) {
-  const db2 = await getDb();
-  const row = await db2.select().from(sessions).where(eq2(sessions.id, sessionId)).get();
+  const db = await getDb();
+  const row = await db.select().from(sessions).where(eq2(sessions.id, sessionId)).get();
   if (!row) return void 0;
   if (Date.now() - row.createdAt > SESSION_MAX_AGE) {
-    await db2.delete(sessions).where(eq2(sessions.id, sessionId));
+    await db.delete(sessions).where(eq2(sessions.id, sessionId));
     return void 0;
   }
   return row.userId;
 }
 async function cleanExpiredSessions() {
-  const db2 = await getDb();
+  const db = await getDb();
   const cutoff = Date.now() - SESSION_MAX_AGE;
-  await db2.delete(sessions).where(lt(sessions.createdAt, cutoff));
+  await db.delete(sessions).where(lt(sessions.createdAt, cutoff));
 }
 var requireAdmin = createMiddleware(async (c, next) => {
   const user = c.get("user");
@@ -1447,30 +1387,44 @@ var authMiddleware = createMiddleware(async (c, next) => {
   if (authHeader?.startsWith("Bearer ")) {
     const token = authHeader.slice(7);
     if (token && isValidDaemonToken(token)) {
-      c.set("user", { id: 0, username: "cli", role: "admin", user_type: "human" });
+      c.set("user", { id: 0, username: "cli", role: "admin", user_type: "brain" });
       await next();
       return;
     }
   }
   const sessionId = getCookie(c, "volute_session");
   if (!sessionId) return c.json({ error: "Unauthorized" }, 401);
+  const cached = sessionCache.get(sessionId);
+  if (cached && cached.expires > Date.now()) {
+    if (cached.user.role === "pending") return c.json({ error: "Account pending approval" }, 403);
+    c.set("user", cached.user);
+    await next();
+    return;
+  }
   const userId = await getSessionUserId(sessionId);
-  if (userId == null) return c.json({ error: "Unauthorized" }, 401);
+  if (userId == null) {
+    sessionCache.delete(sessionId);
+    return c.json({ error: "Unauthorized" }, 401);
+  }
   const user = await getUser(userId);
-  if (!user) return c.json({ error: "Unauthorized" }, 401);
+  if (!user) {
+    sessionCache.delete(sessionId);
+    return c.json({ error: "Unauthorized" }, 401);
+  }
   if (user.role === "pending") return c.json({ error: "Account pending approval" }, 403);
+  sessionCache.set(sessionId, { userId, user, expires: Date.now() + SESSION_CACHE_TTL });
   c.set("user", user);
   await next();
 });
 
 // src/web/server.ts
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { readFile as readFile3, stat as stat2 } from "fs/promises";
-import { dirname as dirname3, extname as extname2, resolve as resolve16 } from "path";
+import { dirname as dirname3, extname as extname2, resolve as resolve18 } from "path";
 import { serve } from "@hono/node-server";
 
 // src/web/app.ts
-import { Hono as Hono17 } from "hono";
+import { Hono as Hono23 } from "hono";
 import { bodyLimit } from "hono/body-limit";
 import { csrf } from "hono/csrf";
 import { HTTPException } from "hono/http-exception";
@@ -1484,6 +1438,17 @@ var credentialsSchema = z.object({
   username: z.string().min(1),
   password: z.string().min(1)
 });
+var changePasswordSchema = z.object({
+  currentPassword: z.string().min(1),
+  newPassword: z.string().min(1)
+});
+var authenticated = new Hono().use(authMiddleware).post("/change-password", zValidator("json", changePasswordSchema), async (c) => {
+  const user = c.get("user");
+  const { currentPassword, newPassword } = c.req.valid("json");
+  const ok = await changePassword(user.id, currentPassword, newPassword);
+  if (!ok) return c.json({ error: "Current password is incorrect" }, 400);
+  return c.json({ ok: true });
+});
 var admin = new Hono().use(authMiddleware).get("/users", async (c) => {
   const user = c.get("user");
   if (user.role !== "admin") return c.json({ error: "Forbidden" }, 403);
@@ -1492,7 +1457,7 @@ var admin = new Hono().use(authMiddleware).get("/users", async (c) => {
     await getOrCreateMindUser(mind.name);
   }
   const type = c.req.query("type");
-  if (type === "human" || type === "mind") {
+  if (type === "brain" || type === "mind") {
     return c.json(await listUsersByType(type));
   }
   return c.json(await listUsers());
@@ -1543,7 +1508,7 @@ var app = new Hono().post("/register", zValidator("json", credentialsSchema), as
   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("/", admin).route("/", authenticated);
 var auth_default = app;
 
 // src/web/api/channels.ts
@@ -1830,18 +1795,109 @@ var app5 = new Hono5().get("/:name/files", async (c) => {
 });
 var files_default = app5;
 
+// src/web/api/keys.ts
+import { Hono as Hono6 } from "hono";
+
+// src/lib/identity.ts
+import { createHash, generateKeyPairSync, sign, verify } from "crypto";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve8 } from "path";
+function generateIdentity(mindDir2) {
+  const identityDir = resolve8(mindDir2, ".mind/identity");
+  mkdirSync4(identityDir, { recursive: true });
+  const { publicKey, privateKey } = generateKeyPairSync("ed25519", {
+    publicKeyEncoding: { type: "spki", format: "pem" },
+    privateKeyEncoding: { type: "pkcs8", format: "pem" }
+  });
+  const privatePath = resolve8(identityDir, "private.pem");
+  const publicPath = resolve8(identityDir, "public.pem");
+  writeFileSync4(privatePath, privateKey, { mode: 384 });
+  writeFileSync4(publicPath, publicKey, { mode: 420 });
+  const config = readVoluteConfig(mindDir2) ?? {};
+  config.identity = {
+    privateKey: ".mind/identity/private.pem",
+    publicKey: ".mind/identity/public.pem"
+  };
+  writeVoluteConfig(mindDir2, config);
+  return { publicKeyPem: publicKey, privateKeyPem: privateKey };
+}
+function getPrivateKey(mindDir2) {
+  const config = readVoluteConfig(mindDir2);
+  const relPath = config?.identity?.privateKey;
+  if (!relPath) return null;
+  const fullPath = resolve8(mindDir2, relPath);
+  if (!existsSync7(fullPath)) return null;
+  return readFileSync5(fullPath, "utf-8");
+}
+function getPublicKey(mindDir2) {
+  const config = readVoluteConfig(mindDir2);
+  const relPath = config?.identity?.publicKey;
+  if (!relPath) return null;
+  const fullPath = resolve8(mindDir2, relPath);
+  if (!existsSync7(fullPath)) return null;
+  return readFileSync5(fullPath, "utf-8");
+}
+function getFingerprint(publicKeyPem) {
+  return createHash("sha256").update(publicKeyPem).digest("hex");
+}
+function signMessage(privateKeyPem, content, timestamp) {
+  const data = `${content}
+${timestamp}`;
+  const signature = sign(null, Buffer.from(data), privateKeyPem);
+  return signature.toString("base64");
+}
+async function publishPublicKey(mindName, publicKeyPem) {
+  const systems = readSystemsConfig();
+  if (!systems) return false;
+  try {
+    const res = await fetch(`${systems.apiUrl}/api/keys/${encodeURIComponent(mindName)}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${systems.apiKey}`
+      },
+      body: JSON.stringify({ publicKey: publicKeyPem })
+    });
+    if (!res.ok) {
+      logger_default.warn(`failed to publish key for ${mindName}: ${res.status}`);
+      return false;
+    }
+    return true;
+  } catch (err) {
+    logger_default.warn(`failed to publish key for ${mindName}`, logger_default.errorData(err));
+    return false;
+  }
+}
+
+// src/web/api/keys.ts
+var app6 = new Hono6().get("/:fingerprint", (c) => {
+  const fingerprint = c.req.param("fingerprint");
+  for (const entry of readRegistry()) {
+    try {
+      const pubKey = getPublicKey(mindDir(entry.name));
+      if (!pubKey) continue;
+      if (getFingerprint(pubKey) === fingerprint) {
+        return c.json({ publicKey: pubKey, mind: entry.name });
+      }
+    } catch {
+    }
+  }
+  return c.json({ error: "Key not found" }, 404);
+});
+var keys_default = app6;
+
 // src/web/api/logs.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync7 } from "fs";
-import { resolve as resolve8 } from "path";
-import { Hono as Hono6 } from "hono";
+import { existsSync as existsSync8 } from "fs";
+import { resolve as resolve9 } from "path";
+import { Hono as Hono7 } from "hono";
 import { streamSSE } from "hono/streaming";
-var app6 = new Hono6().get("/:name/logs", async (c) => {
+var app7 = new Hono7().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 = resolve8(stateDir(name), "logs", "mind.log");
-  if (!existsSync7(logFile)) {
+  const logFile = resolve9(stateDir(name), "logs", "mind.log");
+  if (!existsSync8(logFile)) {
     return c.json({ error: "No log file found" }, 404);
   }
   return streamSSE(c, async (stream) => {
@@ -1859,17 +1915,17 @@ var app6 = new Hono6().get("/:name/logs", async (c) => {
     stream.onAbort(() => {
       tail.kill();
     });
-    await new Promise((resolve18) => {
-      tail.on("exit", resolve18);
-      stream.onAbort(resolve18);
+    await new Promise((resolve20) => {
+      tail.on("exit", resolve20);
+      stream.onAbort(resolve20);
     });
   });
 }).get("/:name/logs/tail", async (c) => {
   const name = c.req.param("name");
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const logFile = resolve8(stateDir(name), "logs", "mind.log");
-  if (!existsSync7(logFile)) {
+  const logFile = resolve9(stateDir(name), "logs", "mind.log");
+  if (!existsSync8(logFile)) {
     return c.json({ error: "No log file found" }, 404);
   }
   const nParam = parseInt(c.req.query("n") ?? "50", 10);
@@ -1879,44 +1935,125 @@ var app6 = new Hono6().get("/:name/logs", async (c) => {
   tail.stdout.on("data", (data) => {
     output += data.toString();
   });
-  await new Promise((resolve18) => {
-    tail.on("exit", resolve18);
+  await new Promise((resolve20) => {
+    tail.on("exit", resolve20);
   });
   return c.text(output);
 });
-var logs_default = app6;
+var logs_default = app7;
+
+// src/web/api/mind-skills.ts
+import { zValidator as zValidator2 } from "@hono/zod-validator";
+import { Hono as Hono8 } from "hono";
+import { z as z2 } from "zod";
+var app8 = new Hono8().get("/:name/skills", 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 skills = await listMindSkills(dir);
+  return c.json(skills);
+}).post(
+  "/:name/skills/install",
+  requireAdmin,
+  zValidator2("json", z2.object({ skillId: z2.string() })),
+  async (c) => {
+    const name = c.req.param("name");
+    const entry = findMind(name);
+    if (!entry) return c.json({ error: "Mind not found" }, 404);
+    const { skillId } = c.req.valid("json");
+    const dir = mindDir(name);
+    try {
+      await installSkill(name, dir, skillId);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      return c.json({ error: msg }, 400);
+    }
+    return c.json({ ok: true });
+  }
+).post(
+  "/:name/skills/update",
+  requireAdmin,
+  zValidator2("json", z2.object({ skillId: z2.string() })),
+  async (c) => {
+    const name = c.req.param("name");
+    const entry = findMind(name);
+    if (!entry) return c.json({ error: "Mind not found" }, 404);
+    const { skillId } = c.req.valid("json");
+    const dir = mindDir(name);
+    try {
+      const result = await updateSkill(name, dir, skillId);
+      return c.json(result);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      return c.json({ error: msg }, 400);
+    }
+  }
+).post(
+  "/:name/skills/publish",
+  requireAdmin,
+  zValidator2("json", z2.object({ skillId: z2.string() })),
+  async (c) => {
+    const name = c.req.param("name");
+    const entry = findMind(name);
+    if (!entry) return c.json({ error: "Mind not found" }, 404);
+    const { skillId } = c.req.valid("json");
+    const dir = mindDir(name);
+    try {
+      const skill = await publishSkill(name, dir, skillId);
+      return c.json(skill);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      return c.json({ error: msg }, 400);
+    }
+  }
+).delete("/:name/skills/:skill", requireAdmin, async (c) => {
+  const name = c.req.param("name");
+  const skillName = c.req.param("skill");
+  const entry = findMind(name);
+  if (!entry) return c.json({ error: "Mind not found" }, 404);
+  const dir = mindDir(name);
+  try {
+    await uninstallSkill(name, dir, skillName);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return c.json({ error: msg }, 400);
+  }
+  return c.json({ ok: true });
+});
+var mind_skills_default = app8;
 
 // src/web/api/minds.ts
 import {
-  cpSync,
-  existsSync as existsSync8,
-  mkdirSync as mkdirSync4,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync6,
-  rmSync,
-  statSync,
-  writeFileSync as writeFileSync5
+  cpSync as cpSync2,
+  existsSync as existsSync10,
+  mkdirSync as mkdirSync7,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync9,
+  rmSync as rmSync2,
+  statSync as statSync2,
+  writeFileSync as writeFileSync8
 } from "fs";
-import { join, resolve as resolve11 } from "path";
-import { zValidator as zValidator2 } from "@hono/zod-validator";
-import { and as and3, desc as desc2, eq as eq4, sql as sql3 } from "drizzle-orm";
-import { Hono as Hono7 } from "hono";
-import { z as z2 } from "zod";
+import { join as join2, resolve as resolve13 } from "path";
+import { zValidator as zValidator3 } from "@hono/zod-validator";
+import { and as and3, desc as desc2, eq as eq4, sql as sql2 } from "drizzle-orm";
+import { Hono as Hono9 } from "hono";
+import { z as z3 } from "zod";
 
 // src/lib/consolidate.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import { resolve as resolve9 } from "path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { resolve as resolve10 } from "path";
 async function consolidateMemory(mindDir2) {
-  const soulPath = resolve9(mindDir2, "home/SOUL.md");
-  const memoryPath = resolve9(mindDir2, "home/MEMORY.md");
-  const memoryDir = resolve9(mindDir2, "home/memory");
-  const soul = readFileSync4(soulPath, "utf-8");
+  const soulPath = resolve10(mindDir2, "home/SOUL.md");
+  const memoryPath = resolve10(mindDir2, "home/MEMORY.md");
+  const memoryDir = resolve10(mindDir2, "home/memory");
+  const soul = readFileSync6(soulPath, "utf-8");
   const logs = [];
   try {
     const files = readdirSync2(memoryDir).filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f)).sort();
     for (const filename of files) {
       const date = filename.replace(".md", "");
-      const content2 = readFileSync4(resolve9(memoryDir, filename), "utf-8").trim();
+      const content2 = readFileSync6(resolve10(memoryDir, filename), "utf-8").trim();
       if (content2) {
         logs.push(`### ${date}
 
@@ -1966,7 +2103,7 @@ ${content2}`);
   const data = await res.json();
   const content = data.content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("").trim();
   if (content) {
-    writeFileSync3(memoryPath, `${content}
+    writeFileSync5(memoryPath, `${content}
 `);
     console.log("MEMORY.md created successfully.");
   } else {
@@ -1976,7 +2113,7 @@ ${content2}`);
 
 // src/lib/conversations.ts
 import { randomUUID } from "crypto";
-import { and as and2, desc, eq as eq3, inArray, isNull, sql as sql2 } from "drizzle-orm";
+import { and as and2, desc, eq as eq3, inArray, isNull, sql } from "drizzle-orm";
 
 // src/lib/conversation-events.ts
 var subscribers = /* @__PURE__ */ new Map();
@@ -2008,13 +2145,17 @@ function publish(conversationId, event) {
 
 // src/lib/conversations.ts
 async function createConversation(mindName, channel, opts) {
-  const db2 = await getDb();
+  const db = await getDb();
   const id = randomUUID();
-  await db2.transaction(async (tx) => {
+  const type = opts?.type ?? "dm";
+  const name = opts?.name ?? null;
+  await db.transaction(async (tx) => {
     await tx.insert(conversations).values({
       id,
       mind_name: mindName,
       channel,
+      type,
+      name,
       user_id: opts?.userId ?? null,
       title: opts?.title ?? null
     });
@@ -2032,6 +2173,8 @@ async function createConversation(mindName, channel, opts) {
     id,
     mind_name: mindName,
     channel,
+    type,
+    name,
     user_id: opts?.userId ?? null,
     title: opts?.title ?? null,
     created_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -2039,13 +2182,30 @@ async function createConversation(mindName, channel, opts) {
   };
 }
 async function getConversation(id) {
-  const db2 = await getDb();
-  const row = await db2.select().from(conversations).where(eq3(conversations.id, id)).get();
+  const db = await getDb();
+  const row = await db.select().from(conversations).where(eq3(conversations.id, id)).get();
   return row ?? null;
 }
+async function addParticipant(conversationId, userId, role = "member") {
+  const db = await getDb();
+  await db.insert(conversationParticipants).values({
+    conversation_id: conversationId,
+    user_id: userId,
+    role
+  });
+}
+async function removeParticipant(conversationId, userId) {
+  const db = await getDb();
+  await db.delete(conversationParticipants).where(
+    and2(
+      eq3(conversationParticipants.conversation_id, conversationId),
+      eq3(conversationParticipants.user_id, userId)
+    )
+  );
+}
 async function getParticipants(conversationId) {
-  const db2 = await getDb();
-  const rows = await db2.select({
+  const db = await getDb();
+  const rows = await db.select({
     userId: conversationParticipants.user_id,
     username: users.username,
     userType: users.user_type,
@@ -2054,8 +2214,8 @@ async function getParticipants(conversationId) {
   return rows;
 }
 async function isParticipant(conversationId, userId) {
-  const db2 = await getDb();
-  const row = await db2.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(
+  const db = await getDb();
+  const row = await db.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(
     and2(
       eq3(conversationParticipants.conversation_id, conversationId),
       eq3(conversationParticipants.user_id, userId)
@@ -2064,16 +2224,16 @@ async function isParticipant(conversationId, userId) {
   return row != null;
 }
 async function listConversationsForUser(userId) {
-  const db2 = await getDb();
-  const participantRows = await db2.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(eq3(conversationParticipants.user_id, userId)).all();
+  const db = await getDb();
+  const participantRows = await db.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(eq3(conversationParticipants.user_id, userId)).all();
   if (participantRows.length === 0) return [];
   const convIds = participantRows.map((r) => r.conversation_id);
-  return db2.select().from(conversations).where(inArray(conversations.id, convIds)).orderBy(desc(conversations.updated_at)).all();
+  return await db.select().from(conversations).where(inArray(conversations.id, convIds)).orderBy(desc(conversations.updated_at)).all();
 }
 async function isParticipantOrOwner(conversationId, userId) {
   if (await isParticipant(conversationId, userId)) return true;
-  const db2 = await getDb();
-  const row = await db2.select().from(conversations).where(and2(eq3(conversations.id, conversationId), eq3(conversations.user_id, userId))).get();
+  const db = await getDb();
+  const row = await db.select().from(conversations).where(and2(eq3(conversations.id, conversationId), eq3(conversations.user_id, userId))).get();
   return row != null;
 }
 async function deleteConversationForUser(id, userId) {
@@ -2082,15 +2242,15 @@ async function deleteConversationForUser(id, userId) {
   return true;
 }
 async function addMessage(conversationId, role, senderName, content) {
-  const db2 = await getDb();
+  const db = await getDb();
   const serialized = JSON.stringify(content);
-  const [result] = await db2.insert(messages).values({ conversation_id: conversationId, role, sender_name: senderName, content: serialized }).returning({ id: messages.id, created_at: messages.created_at });
-  await db2.update(conversations).set({ updated_at: sql2`datetime('now')` }).where(eq3(conversations.id, conversationId));
+  const [result] = await db.insert(messages).values({ conversation_id: conversationId, role, sender_name: senderName, content: serialized }).returning({ id: messages.id, created_at: messages.created_at });
+  await db.update(conversations).set({ updated_at: sql`datetime('now')` }).where(eq3(conversations.id, conversationId));
   if (role === "user") {
     const firstText = content.find((b) => b.type === "text");
     const title = firstText ? firstText.text.slice(0, 80) : "";
     if (title) {
-      await db2.update(conversations).set({ title }).where(and2(eq3(conversations.id, conversationId), isNull(conversations.title)));
+      await db.update(conversations).set({ title }).where(and2(eq3(conversations.id, conversationId), isNull(conversations.title)));
     }
   }
   const msg = {
@@ -2112,8 +2272,8 @@ async function addMessage(conversationId, role, senderName, content) {
   return msg;
 }
 async function getMessages(conversationId) {
-  const db2 = await getDb();
-  const rows = await db2.select().from(messages).where(eq3(messages.conversation_id, conversationId)).orderBy(messages.created_at).all();
+  const db = await getDb();
+  const rows = await db.select().from(messages).where(eq3(messages.conversation_id, conversationId)).orderBy(messages.created_at).all();
   return rows.map((row) => {
     let content;
     try {
@@ -2128,9 +2288,9 @@ async function getMessages(conversationId) {
 async function listConversationsWithParticipants(userId) {
   const convs = await listConversationsForUser(userId);
   if (convs.length === 0) return [];
-  const db2 = await getDb();
+  const db = await getDb();
   const convIds = convs.map((c) => c.id);
-  const rows = await db2.select({
+  const rows = await db.select({
     conversationId: conversationParticipants.conversation_id,
     userId: users.id,
     username: users.username,
@@ -2151,32 +2311,32 @@ async function listConversationsWithParticipants(userId) {
       role: r.role
     });
   }
-  const lastMsgIds = await db2.select({
+  const lastMsgIds = await db.select({
     conversationId: messages.conversation_id,
-    maxId: sql2`MAX(${messages.id})`
+    maxId: sql`MAX(${messages.id})`
   }).from(messages).where(inArray(messages.conversation_id, convIds)).groupBy(messages.conversation_id);
   const byLastMsg = /* @__PURE__ */ new Map();
   if (lastMsgIds.length > 0) {
-    const msgRows = await db2.select().from(messages).where(
+    const msgRows = await db.select().from(messages).where(
       inArray(
         messages.id,
         lastMsgIds.map((r) => r.maxId)
       )
     );
     for (const m of msgRows) {
-      let text2 = "";
+      let text = "";
       try {
         const parsed = JSON.parse(m.content);
         const blocks = Array.isArray(parsed) ? parsed : [];
         const textBlock = blocks.find((b) => b.type === "text");
-        if (textBlock && "text" in textBlock) text2 = textBlock.text;
+        if (textBlock && "text" in textBlock) text = textBlock.text;
       } catch {
-        text2 = m.content;
+        text = m.content;
       }
       byLastMsg.set(m.conversation_id, {
         role: m.role,
         senderName: m.sender_name,
-        text: text2,
+        text,
         createdAt: m.created_at
       });
     }
@@ -2188,10 +2348,10 @@ async function listConversationsWithParticipants(userId) {
   }));
 }
 async function findDMConversation(mindName, participantIds) {
-  const db2 = await getDb();
-  const mindConvs = await db2.select({ id: conversations.id }).from(conversations).where(eq3(conversations.mind_name, mindName)).all();
+  const db = await getDb();
+  const mindConvs = await db.select({ id: conversations.id }).from(conversations).where(and2(eq3(conversations.mind_name, mindName), eq3(conversations.type, "dm"))).all();
   for (const conv of mindConvs) {
-    const rows = await db2.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(eq3(conversationParticipants.conversation_id, conv.id)).all();
+    const rows = await db.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(eq3(conversationParticipants.conversation_id, conv.id)).all();
     if (rows.length !== 2) continue;
     const ids = new Set(rows.map((r) => r.user_id));
     if (ids.has(participantIds[0]) && ids.has(participantIds[1])) {
@@ -2201,17 +2361,42 @@ async function findDMConversation(mindName, participantIds) {
   return null;
 }
 async function deleteConversation(id) {
-  const db2 = await getDb();
-  await db2.delete(conversations).where(eq3(conversations.id, id));
+  const db = await getDb();
+  await db.delete(conversations).where(eq3(conversations.id, id));
+}
+async function createChannel(name, creatorId) {
+  const participantIds = creatorId ? [creatorId] : [];
+  return createConversation(null, "volute", {
+    type: "channel",
+    name,
+    title: name,
+    participantIds
+  });
+}
+async function getChannelByName(name) {
+  const db = await getDb();
+  const row = await db.select().from(conversations).where(and2(eq3(conversations.name, name), eq3(conversations.type, "channel"))).get();
+  return row ?? null;
+}
+async function listChannels() {
+  const db = await getDb();
+  return await db.select().from(conversations).where(eq3(conversations.type, "channel")).orderBy(conversations.name).all();
+}
+async function joinChannel(conversationId, userId) {
+  if (await isParticipant(conversationId, userId)) return;
+  await addParticipant(conversationId, userId);
+}
+async function leaveChannel(conversationId, userId) {
+  await removeParticipant(conversationId, userId);
 }
 
 // src/lib/convert-session.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
 import { homedir } from "os";
-import { resolve as resolve10 } from "path";
+import { resolve as resolve11 } from "path";
 function convertSession(opts) {
-  const lines = readFileSync5(opts.sessionPath, "utf-8").trim().split("\n");
+  const lines = readFileSync7(opts.sessionPath, "utf-8").trim().split("\n");
   const sessionId = randomUUID2();
   const idMap = /* @__PURE__ */ new Map();
   const messages2 = [];
@@ -2325,10 +2510,10 @@ function convertSession(opts) {
     }
   }
   const projectId = opts.projectDir.replace(/\//g, "-");
-  const sdkDir = resolve10(homedir(), ".claude", "projects", projectId);
-  mkdirSync3(sdkDir, { recursive: true });
-  const sdkPath = resolve10(sdkDir, `${sessionId}.jsonl`);
-  writeFileSync4(sdkPath, `${sdkEvents.join("\n")}
+  const sdkDir = resolve11(homedir(), ".claude", "projects", projectId);
+  mkdirSync5(sdkDir, { recursive: true });
+  const sdkPath = resolve11(sdkDir, `${sessionId}.jsonl`);
+  writeFileSync6(sdkPath, `${sdkEvents.join("\n")}
 `);
   console.log(`Converted ${sdkEvents.length} messages \u2192 ${sdkPath}`);
   return sessionId;
@@ -2407,121 +2592,112 @@ function publish2(mind, event) {
   }
 }
 
-// src/lib/typing.ts
-var DEFAULT_TTL_MS = 1e4;
-var SWEEP_INTERVAL_MS = 5e3;
-var TypingMap = class {
-  channels = /* @__PURE__ */ new Map();
-  sweepTimer;
-  constructor() {
-    this.sweepTimer = setInterval(() => this.sweep(), SWEEP_INTERVAL_MS);
-    this.sweepTimer.unref();
-  }
-  set(channel, sender, opts) {
-    const expiresAt = opts?.persistent ? Infinity : Date.now() + (opts?.ttlMs ?? DEFAULT_TTL_MS);
-    let senders = this.channels.get(channel);
-    if (!senders) {
-      senders = /* @__PURE__ */ new Map();
-      this.channels.set(channel, senders);
-    }
-    senders.set(sender, { expiresAt });
-  }
-  delete(channel, sender) {
-    const senders = this.channels.get(channel);
-    if (senders) {
-      senders.delete(sender);
-      if (senders.size === 0) {
-        this.channels.delete(channel);
-      }
-    }
+// src/lib/template.ts
+import {
+  cpSync,
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync6,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync8,
+  renameSync as renameSync3,
+  rmSync,
+  statSync,
+  writeFileSync as writeFileSync7
+} from "fs";
+import { tmpdir } from "os";
+import { dirname as dirname2, join, relative, resolve as resolve12 } from "path";
+function findTemplatesRoot() {
+  let dir = dirname2(new URL(import.meta.url).pathname);
+  for (let i = 0; i < 5; i++) {
+    const candidate = resolve12(dir, "templates");
+    if (existsSync9(resolve12(candidate, "_base"))) return candidate;
+    dir = dirname2(dir);
   }
-  /** Remove a sender from all channels (e.g. when a mind finishes processing). */
-  deleteSender(sender) {
-    for (const [channel, senders] of this.channels) {
-      senders.delete(sender);
-      if (senders.size === 0) {
-        this.channels.delete(channel);
-      }
-    }
+  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 = resolve12(templatesRoot, "_base");
+  const templateDir = resolve12(templatesRoot, templateName);
+  if (!existsSync9(baseDir)) {
+    console.error("Base template not found:", baseDir);
+    process.exit(1);
+  }
+  if (!existsSync9(templateDir)) {
+    console.error(`Template not found: ${templateName}`);
+    process.exit(1);
+  }
+  const composedDir = resolve12(tmpdir(), `volute-template-${Date.now()}`);
+  mkdirSync6(composedDir, { recursive: true });
+  cpSync(baseDir, composedDir, { recursive: true });
+  for (const file of listFiles(templateDir)) {
+    const src = resolve12(templateDir, file);
+    const dest = resolve12(composedDir, file);
+    mkdirSync6(dirname2(dest), { recursive: true });
+    cpSync(src, dest);
+  }
+  const manifestPath = resolve12(composedDir, "volute-template.json");
+  if (!existsSync9(manifestPath)) {
+    rmSync(composedDir, { recursive: true, force: true });
+    console.error(`Template manifest not found: ${templateName}/volute-template.json`);
+    process.exit(1);
   }
-  get(channel) {
-    const senders = this.channels.get(channel);
-    if (!senders) return [];
-    const now = Date.now();
-    const result = [];
-    for (const [sender, entry] of senders) {
-      if (entry.expiresAt > now) {
-        result.push(sender);
-      }
+  const manifest = JSON.parse(readFileSync8(manifestPath, "utf-8"));
+  rmSync(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 = resolve12(destDir, from);
+    if (existsSync9(fromPath)) {
+      renameSync3(fromPath, resolve12(destDir, to));
     }
-    return result;
   }
-  dispose() {
-    clearInterval(this.sweepTimer);
-    this.channels.clear();
-    if (instance5 === this) instance5 = void 0;
+  for (const file of manifest.substitute) {
+    const path = resolve12(destDir, file);
+    if (existsSync9(path)) {
+      const content = readFileSync8(path, "utf-8");
+      writeFileSync7(path, content.replaceAll("{{name}}", mindName));
+    }
   }
-  sweep() {
-    const now = Date.now();
-    for (const [channel, senders] of this.channels) {
-      for (const [sender, entry] of senders) {
-        if (entry.expiresAt <= now) {
-          senders.delete(sender);
-        }
-      }
-      if (senders.size === 0) {
-        this.channels.delete(channel);
+}
+function applyInitFiles(destDir) {
+  const initDir = resolve12(destDir, ".init");
+  if (!existsSync9(initDir)) return;
+  const homeDir = resolve12(destDir, "home");
+  for (const file of listFiles(initDir)) {
+    const src = resolve12(initDir, file);
+    const dest = resolve12(homeDir, file);
+    const parent = dirname2(dest);
+    if (!existsSync9(parent)) {
+      mkdirSync6(parent, { recursive: true });
+    }
+    cpSync(src, dest);
+  }
+  rmSync(initDir, { recursive: true, force: true });
+}
+function listFiles(dir) {
+  const results = [];
+  function walk(current) {
+    for (const entry of readdirSync3(current)) {
+      const full = join(current, entry);
+      if (statSync(full).isDirectory()) {
+        if (entry === ".git") continue;
+        walk(full);
+      } else {
+        results.push(relative(dir, full));
       }
     }
   }
-};
-var instance5;
-function getTypingMap() {
-  if (!instance5) {
-    instance5 = new TypingMap();
-  }
-  return instance5;
+  walk(dir);
+  return results;
 }
 
 // src/web/api/minds.ts
-async function startMindFull(name, baseName, variantName) {
-  await getMindManager().startMind(name);
-  if (variantName) return;
-  if (findMind(baseName)?.stage === "seed") return;
-  const dir = mindDir(baseName);
-  const entry = findMind(baseName);
-  await getConnectorManager().startConnectors(baseName, dir, entry.port, getDaemonPort());
-  getScheduler().loadSchedules(baseName);
-  ensureMailAddress(baseName).catch(
-    (err) => console.error(`[mail] failed to ensure address for ${baseName}:`, err)
-  );
-  const config = readVoluteConfig(dir);
-  if (config?.tokenBudget) {
-    getTokenBudget().setBudget(
-      baseName,
-      config.tokenBudget,
-      config.tokenBudgetPeriodMinutes ?? DEFAULT_BUDGET_PERIOD_MINUTES
-    );
-  }
-}
-function extractTextContent(content) {
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content.filter((p) => p.type === "text" && p.text).map((p) => p.text).join("\n");
-  }
-  return JSON.stringify(content);
-}
-function getDaemonPort() {
-  try {
-    const data = JSON.parse(readFileSync6(resolve11(voluteHome(), "daemon.json"), "utf-8"));
-    return data.port;
-  } catch (err) {
-    if (err?.code !== "ENOENT") {
-      console.error("[daemon] failed to read daemon.json:", err);
-    }
-    return void 0;
-  }
-}
 async function getMindStatus(name, port) {
   const manager = getMindManager();
   let status = "stopped";
@@ -2564,7 +2740,7 @@ async function initTemplateBranch(projectRoot, composedDir, manifest, mindName,
   await gitExec(["commit", "-m", "initial commit"], opts);
 }
 async function updateTemplateBranch(projectRoot, template, mindName) {
-  const tempWorktree = resolve11(projectRoot, ".variants", "_template_update");
+  const tempWorktree = resolve13(projectRoot, ".variants", "_template_update");
   let branchExists = false;
   try {
     await gitExec(["rev-parse", "--verify", TEMPLATE_BRANCH], { cwd: projectRoot });
@@ -2575,8 +2751,8 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
     await gitExec(["worktree", "remove", "--force", tempWorktree], { cwd: projectRoot });
   } catch {
   }
-  if (existsSync8(tempWorktree)) {
-    rmSync(tempWorktree, { recursive: true, force: true });
+  if (existsSync10(tempWorktree)) {
+    rmSync2(tempWorktree, { recursive: true, force: true });
   }
   const templatesRoot = findTemplatesRoot();
   const { composedDir, manifest } = composeTemplate(templatesRoot, template);
@@ -2596,9 +2772,9 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
       });
     }
     copyTemplateToDir(composedDir, tempWorktree, mindName, manifest);
-    const initDir = resolve11(tempWorktree, ".init");
-    if (existsSync8(initDir)) {
-      rmSync(initDir, { recursive: true, force: true });
+    const initDir = resolve13(tempWorktree, ".init");
+    if (existsSync10(initDir)) {
+      rmSync2(initDir, { recursive: true, force: true });
     }
     await gitExec(["add", "-A"], { cwd: tempWorktree });
     try {
@@ -2611,10 +2787,10 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
       await gitExec(["worktree", "remove", "--force", tempWorktree], { cwd: projectRoot });
     } catch {
     }
-    if (existsSync8(tempWorktree)) {
-      rmSync(tempWorktree, { recursive: true, force: true });
+    if (existsSync10(tempWorktree)) {
+      rmSync2(tempWorktree, { recursive: true, force: true });
     }
-    rmSync(composedDir, { recursive: true, force: true });
+    rmSync2(composedDir, { recursive: true, force: true });
   }
 }
 async function mergeTemplateBranch(worktreeDir) {
@@ -2637,19 +2813,125 @@ async function mergeTemplateBranch(worktreeDir) {
 async function npmInstallAsMind(cwd, mindName) {
   if (isIsolationEnabled()) {
     const [cmd, args] = wrapForIsolation("npm", ["install"], mindName);
-    await exec(cmd, args, { cwd, env: { ...process.env, HOME: resolve11(cwd, "home") } });
+    await exec(cmd, args, { cwd, env: { ...process.env, HOME: resolve13(cwd, "home") } });
   } else {
     await exec("npm", ["install"], { cwd });
   }
 }
-var createMindSchema = z2.object({
-  name: z2.string(),
-  template: z2.string().optional(),
-  stage: z2.enum(["seed", "sprouted"]).optional(),
-  description: z2.string().optional(),
-  model: z2.string().optional()
+async function importFromArchive(c, tempDir, nameOverride, manifest) {
+  const extractedMindDir = resolve13(tempDir, "mind");
+  if (!existsSync10(extractedMindDir)) {
+    return c.json({ error: "Invalid archive: missing mind/ directory" }, 400);
+  }
+  if (!manifest?.includes || !manifest.name || !manifest.template) {
+    return c.json({ error: "Invalid archive manifest" }, 400);
+  }
+  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 (existsSync10(dest)) return c.json({ error: "Mind directory already exists" }, 409);
+  try {
+    cpSync2(extractedMindDir, dest, { recursive: true });
+    if (!manifest.includes.identity) {
+      generateIdentity(dest);
+    }
+    const state = stateDir(name);
+    mkdirSync7(state, { recursive: true });
+    const channelsJson = resolve13(tempDir, "state/channels.json");
+    if (existsSync10(channelsJson)) {
+      cpSync2(channelsJson, resolve13(state, "channels.json"));
+    }
+    const envJson = resolve13(tempDir, "state/env.json");
+    if (existsSync10(envJson)) {
+      cpSync2(envJson, resolve13(state, "env.json"));
+    }
+    const port = nextPort();
+    addMind(name, port, void 0, manifest.template);
+    const homeDir = resolve13(dest, "home");
+    ensureVoluteGroup();
+    createMindUser(name, homeDir);
+    chownMindDir(dest, name);
+    await npmInstallAsMind(dest, name);
+    const historyJsonl = resolve13(tempDir, "history.jsonl");
+    if (existsSync10(historyJsonl)) {
+      try {
+        const db = await getDb();
+        const lines = readFileSync9(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));
+      }
+    }
+    const sessionsDir = resolve13(tempDir, "sessions");
+    if (existsSync10(sessionsDir)) {
+      const destSessions = resolve13(dest, ".mind/sessions");
+      mkdirSync7(destSessions, { recursive: true });
+      for (const file of readdirSync4(sessionsDir)) {
+        cpSync2(resolve13(sessionsDir, file), resolve13(destSessions, file));
+      }
+    }
+    if (!existsSync10(resolve13(dest, ".git"))) {
+      const env = isIsolationEnabled() ? { ...process.env, HOME: resolve13(dest, "home") } : void 0;
+      await gitExec(["init"], { 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 });
+    }
+    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 (existsSync10(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));
+    }
+    rmSync2(tempDir, { recursive: true, force: true });
+    return c.json({ error: err instanceof Error ? err.message : "Failed to import mind" }, 500);
+  }
+}
+var createMindSchema = z3.object({
+  name: z3.string(),
+  template: z3.string().optional(),
+  stage: z3.enum(["seed", "sprouted"]).optional(),
+  description: z3.string().optional(),
+  model: z3.string().optional(),
+  seedSoul: z3.string().optional(),
+  skills: z3.array(z3.string()).optional()
 });
-var app7 = new Hono7().post("/", requireAdmin, zValidator2("json", createMindSchema), async (c) => {
+var app9 = new Hono9().post("/", requireAdmin, zValidator3("json", createMindSchema), async (c) => {
   const body = c.req.valid("json");
   const { name, template = "claude" } = body;
   const nameErr = validateMindName(name);
@@ -2657,22 +2939,29 @@ var app7 = new Hono7().post("/", requireAdmin, zValidator2("json", createMindSch
   if (findMind(name)) return c.json({ error: `Mind already exists: ${name}` }, 409);
   ensureVoluteHome();
   const dest = mindDir(name);
-  if (existsSync8(dest)) return c.json({ error: "Mind directory already exists" }, 409);
+  if (existsSync10(dest)) return c.json({ error: "Mind directory already exists" }, 409);
   const templatesRoot = findTemplatesRoot();
   const { composedDir, manifest } = composeTemplate(templatesRoot, template);
   try {
     copyTemplateToDir(composedDir, dest, name, manifest);
     applyInitFiles(dest);
+    const { publicKeyPem } = generateIdentity(dest);
     if (body.model) {
-      const configPath = resolve11(dest, "home/.config/config.json");
-      const existing = existsSync8(configPath) ? JSON.parse(readFileSync6(configPath, "utf-8")) : {};
+      const configPath = resolve13(dest, "home/.config/config.json");
+      const existing = existsSync10(configPath) ? JSON.parse(readFileSync9(configPath, "utf-8")) : {};
       existing.model = body.model;
-      writeFileSync5(configPath, `${JSON.stringify(existing, null, 2)}
+      writeFileSync8(configPath, `${JSON.stringify(existing, null, 2)}
 `);
     }
+    const mindPrompts = await getMindPromptDefaults();
+    writeFileSync8(
+      resolve13(dest, "home/.config/prompts.json"),
+      `${JSON.stringify(mindPrompts, null, 2)}
+`
+    );
     const port = nextPort();
-    addMind(name, port, body.stage);
-    const homeDir = resolve11(dest, "home");
+    addMind(name, port, body.stage, template);
+    const homeDir = resolve13(dest, "home");
     ensureVoluteGroup();
     createMindUser(name, homeDir);
     chownMindDir(dest, name);
@@ -2683,47 +2972,65 @@ var app7 = new Hono7().post("/", requireAdmin, zValidator2("json", createMindSch
       await gitExec(["init"], { cwd: dest, mindName: name, env });
       await initTemplateBranch(dest, composedDir, manifest, name, env);
     } catch (err) {
-      console.error(`[daemon] git setup failed for ${name}:`, err);
-      rmSync(resolve11(dest, ".git"), { recursive: true, force: true });
+      logger_default.error(`git setup failed for ${name}`, logger_default.errorData(err));
+      rmSync2(resolve13(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));
+    }
     chownMindDir(dest, name);
     if (body.stage === "seed") {
       const descLine = body.description ? `
 The human who planted you described you as: "${body.description}"
 ` : "";
-      writeFileSync5(
-        resolve11(dest, "home/SOUL.md"),
-        `You are ${name}.
-
-You don't have a soul yet. You're a seed \u2014 a new mind in the process of discovering who you are.
-${descLine}
-Have a conversation with the human. Explore what kind of mind you want to be. When you're ready, write your SOUL.md and MEMORY.md, then run \`volute sprout\` to complete the transformation.
-`
-      );
-      const skillsDir = resolve11(dest, manifest.skillsDir);
-      for (const skill of ["volute-mind", "memory", "sessions"]) {
-        const skillPath = resolve11(skillsDir, skill);
-        if (existsSync8(skillPath)) rmSync(skillPath, { recursive: true, force: true });
+      const seedSoulRaw = body.seedSoul ?? await getPrompt("seed_soul", { name, description: descLine });
+      const seedSoul = body.seedSoul ? substitute(seedSoulRaw, { name, description: descLine }) : seedSoulRaw;
+      writeFileSync8(resolve13(dest, "home/SOUL.md"), seedSoul);
+    }
+    const skillSet = body.skills ?? (body.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}`);
+      }
+    }
+    if (body.stage !== "seed") {
+      const customSoul = await getPromptIfCustom("default_soul");
+      if (customSoul) {
+        writeFileSync8(resolve13(dest, "home/SOUL.md"), customSoul.replace(/\{\{name\}\}/g, name));
+      }
+      const customMemory = await getPromptIfCustom("default_memory");
+      if (customMemory) {
+        writeFileSync8(resolve13(dest, "home/MEMORY.md"), customMemory);
       }
     }
+    publishPublicKey(name, publicKeyPem).catch(
+      (err) => logger_default.warn(`failed to publish key for ${name}`, { error: err.message })
+    );
     return c.json({
       ok: true,
       name,
       port,
       stage: body.stage ?? "sprouted",
       message: `Created mind: ${name} (port ${port})`,
-      ...gitWarning && { warning: gitWarning }
+      ...gitWarning && { warning: gitWarning },
+      ...skillWarnings.length > 0 && { skillWarnings }
     });
   } catch (err) {
-    if (existsSync8(dest)) rmSync(dest, { recursive: true, force: true });
+    if (existsSync10(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 {
-    rmSync(composedDir, { recursive: true, force: true });
+    rmSync2(composedDir, { recursive: true, force: true });
   }
 }).post("/import", requireAdmin, async (c) => {
   let body;
@@ -2732,14 +3039,17 @@ Have a conversation with the human. Explore what kind of mind you want to be. Wh
   } catch {
     return c.json({ error: "Invalid JSON" }, 400);
   }
+  if (body.archivePath && body.manifest) {
+    return importFromArchive(c, body.archivePath, body.name, body.manifest);
+  }
   const wsDir = body.workspacePath;
-  if (!wsDir || !existsSync8(resolve11(wsDir, "SOUL.md")) || !existsSync8(resolve11(wsDir, "IDENTITY.md"))) {
+  if (!wsDir || !existsSync10(resolve13(wsDir, "SOUL.md")) || !existsSync10(resolve13(wsDir, "IDENTITY.md"))) {
     return c.json({ error: "Invalid workspace: missing SOUL.md or IDENTITY.md" }, 400);
   }
-  const soul = readFileSync6(resolve11(wsDir, "SOUL.md"), "utf-8");
-  const identity = readFileSync6(resolve11(wsDir, "IDENTITY.md"), "utf-8");
-  const userPath = resolve11(wsDir, "USER.md");
-  const user = existsSync8(userPath) ? readFileSync6(userPath, "utf-8") : "";
+  const soul = readFileSync9(resolve13(wsDir, "SOUL.md"), "utf-8");
+  const identity = readFileSync9(resolve13(wsDir, "IDENTITY.md"), "utf-8");
+  const userPath = resolve13(wsDir, "USER.md");
+  const user = existsSync10(userPath) ? readFileSync9(userPath, "utf-8") : "";
   const name = body.name ?? parseNameFromIdentity(identity) ?? "imported-mind";
   const template = body.template ?? "claude";
   const nameErr = validateMindName(name);
@@ -2759,38 +3069,39 @@ ${user.trimEnd()}
 ` : "";
   ensureVoluteHome();
   const dest = mindDir(name);
-  if (existsSync8(dest)) return c.json({ error: "Mind directory already exists" }, 409);
+  if (existsSync10(dest)) return c.json({ error: "Mind directory already exists" }, 409);
   const templatesRoot = findTemplatesRoot();
   const { composedDir, manifest } = composeTemplate(templatesRoot, template);
   try {
     copyTemplateToDir(composedDir, dest, name, manifest);
     applyInitFiles(dest);
-    writeFileSync5(resolve11(dest, "home/SOUL.md"), mergedSoul);
-    const wsMemoryPath = resolve11(wsDir, "MEMORY.md");
-    const hasMemory = existsSync8(wsMemoryPath);
+    const { publicKeyPem: importPublicKey } = generateIdentity(dest);
+    writeFileSync8(resolve13(dest, "home/SOUL.md"), mergedSoul);
+    const wsMemoryPath = resolve13(wsDir, "MEMORY.md");
+    const hasMemory = existsSync10(wsMemoryPath);
     if (hasMemory) {
-      const existingMemory = readFileSync6(wsMemoryPath, "utf-8");
-      writeFileSync5(
-        resolve11(dest, "home/MEMORY.md"),
+      const existingMemory = readFileSync9(wsMemoryPath, "utf-8");
+      writeFileSync8(
+        resolve13(dest, "home/MEMORY.md"),
         `${existingMemory.trimEnd()}${mergedMemoryExtra}`
       );
     } else if (user) {
-      writeFileSync5(resolve11(dest, "home/MEMORY.md"), `${user.trimEnd()}
+      writeFileSync8(resolve13(dest, "home/MEMORY.md"), `${user.trimEnd()}
 `);
     }
-    const wsMemoryDir = resolve11(wsDir, "memory");
+    const wsMemoryDir = resolve13(wsDir, "memory");
     let dailyLogCount = 0;
-    if (existsSync8(wsMemoryDir)) {
-      const destMemoryDir = resolve11(dest, "home/memory");
-      const files = readdirSync3(wsMemoryDir).filter((f) => f.endsWith(".md"));
+    if (existsSync10(wsMemoryDir)) {
+      const destMemoryDir = resolve13(dest, "home/memory");
+      const files = readdirSync4(wsMemoryDir).filter((f) => f.endsWith(".md"));
       for (const file of files) {
-        cpSync(resolve11(wsMemoryDir, file), resolve11(destMemoryDir, file));
+        cpSync2(resolve13(wsMemoryDir, file), resolve13(destMemoryDir, file));
       }
       dailyLogCount = files.length;
     }
     const port = nextPort();
-    addMind(name, port);
-    const homeDir = resolve11(dest, "home");
+    addMind(name, port, void 0, template);
+    const homeDir = resolve13(dest, "home");
     ensureVoluteGroup();
     createMindUser(name, homeDir);
     chownMindDir(dest, name);
@@ -2798,42 +3109,50 @@ ${user.trimEnd()}
     if (!hasMemory && dailyLogCount > 0) {
       await consolidateMemory(dest);
     }
-    const env = isIsolationEnabled() ? { ...process.env, HOME: resolve11(dest, "home") } : void 0;
+    const env = isIsolationEnabled() ? { ...process.env, HOME: resolve13(dest, "home") } : void 0;
     await gitExec(["init"], { cwd: dest, mindName: name, env });
     await gitExec(["add", "-A"], { cwd: dest, mindName: name, env });
     await gitExec(["commit", "-m", "import from OpenClaw"], { cwd: dest, mindName: name, env });
-    const sessionFile = body.sessionPath ? resolve11(body.sessionPath) : findOpenClawSession(wsDir);
-    if (sessionFile && existsSync8(sessionFile)) {
+    const sessionFile = body.sessionPath ? resolve13(body.sessionPath) : findOpenClawSession(wsDir);
+    if (sessionFile && existsSync10(sessionFile)) {
       if (template === "pi") {
         importPiSession(sessionFile, dest);
       } else if (template === "claude") {
         const sessionId = convertSession({ sessionPath: sessionFile, projectDir: dest });
-        const voluteDir = resolve11(dest, ".volute");
-        mkdirSync4(voluteDir, { recursive: true });
-        writeFileSync5(resolve11(voluteDir, "session.json"), JSON.stringify({ sessionId }));
+        const mindRuntimeDir = resolve13(dest, ".mind");
+        mkdirSync7(mindRuntimeDir, { recursive: true });
+        writeFileSync8(resolve13(mindRuntimeDir, "session.json"), JSON.stringify({ sessionId }));
       }
     }
     importOpenClawConnectors(name, dest);
+    try {
+      await addSharedWorktree(name, dest);
+    } catch (err) {
+      logger_default.warn(`failed to add shared worktree for ${name}`, logger_default.errorData(err));
+    }
     chownMindDir(dest, name);
+    publishPublicKey(name, importPublicKey).catch(
+      (err) => logger_default.warn(`failed to publish key for ${name}`, { error: err.message })
+    );
     return c.json({ ok: true, name, port, message: `Imported mind: ${name} (port ${port})` });
   } catch (err) {
-    if (existsSync8(dest)) rmSync(dest, { recursive: true, force: true });
+    if (existsSync10(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 {
-    rmSync(composedDir, { recursive: true, force: true });
+    rmSync2(composedDir, { recursive: true, force: true });
   }
 }).get("/", async (c) => {
   const entries = readRegistry();
   let lastActiveMap = /* @__PURE__ */ new Map();
   try {
-    const db2 = await getDb();
-    const lastActiveRows = await db2.select({
+    const db = await getDb();
+    const lastActiveRows = await db.select({
       mind: mindHistory.mind,
-      lastActiveAt: sql3`MAX(${mindHistory.created_at})`
+      lastActiveAt: sql2`MAX(${mindHistory.created_at})`
     }).from(mindHistory).groupBy(mindHistory.mind);
     lastActiveMap = new Map(lastActiveRows.map((r) => [r.mind, r.lastActiveAt]));
   } catch {
@@ -2841,7 +3160,7 @@ ${user.trimEnd()}
   const minds = await Promise.all(
     entries.map(async (entry) => {
       const { status, channels } = await getMindStatus(entry.name, entry.port);
-      const hasPages = existsSync8(resolve11(mindDir(entry.name), "home", "pages"));
+      const hasPages = existsSync10(resolve13(mindDir(entry.name), "home", "pages"));
       return {
         ...entry,
         status,
@@ -2856,19 +3175,19 @@ ${user.trimEnd()}
   const entries = readRegistry();
   const pages = [];
   for (const entry of entries) {
-    const pagesDir = resolve11(mindDir(entry.name), "home", "pages");
-    if (!existsSync8(pagesDir)) continue;
+    const pagesDir = resolve13(mindDir(entry.name), "home", "pages");
+    if (!existsSync10(pagesDir)) continue;
     let items;
     try {
-      items = readdirSync3(pagesDir);
+      items = readdirSync4(pagesDir);
     } catch (err) {
       logger_default.warn("Failed to read pages dir", { mind: entry.name, error: err.message });
       continue;
     }
     for (const item of items) {
-      const fullPath = resolve11(pagesDir, item);
+      const fullPath = resolve13(pagesDir, item);
       try {
-        const s = statSync(fullPath);
+        const s = statSync2(fullPath);
         if (s.isFile()) {
           pages.push({
             mind: entry.name,
@@ -2877,12 +3196,12 @@ ${user.trimEnd()}
             url: `/pages/${entry.name}/${item}`
           });
         } else if (s.isDirectory()) {
-          const indexPath = resolve11(fullPath, "index.html");
-          if (existsSync8(indexPath)) {
-            const indexStat = statSync(indexPath);
+          const indexPath = resolve13(fullPath, "index.html");
+          if (existsSync10(indexPath)) {
+            const indexStat = statSync2(indexPath);
             pages.push({
               mind: entry.name,
-              file: join(item, "index.html"),
+              file: join2(item, "index.html"),
               modified: indexStat.mtime.toISOString(),
               url: `/pages/${entry.name}/${item}/`
             });
@@ -2903,7 +3222,7 @@ ${user.trimEnd()}
   const name = c.req.param("name");
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  if (!existsSync8(mindDir(name))) return c.json({ error: "Mind directory missing" }, 404);
+  if (!existsSync10(mindDir(name))) return c.json({ error: "Mind directory missing" }, 404);
   const { status, channels } = await getMindStatus(name, entry.port);
   const variants = readVariants(name);
   const manager = getMindManager();
@@ -2918,7 +3237,7 @@ ${user.trimEnd()}
       return { name: v.name, port: v.port, status: variantStatus };
     })
   );
-  const hasPages = existsSync8(resolve11(mindDir(name), "home", "pages"));
+  const hasPages = existsSync10(resolve13(mindDir(name), "home", "pages"));
   return c.json({ ...entry, status, channels, variants: variantStatuses, hasPages });
 }).post("/:name/start", requireAdmin, async (c) => {
   const name = c.req.param("name");
@@ -2930,13 +3249,13 @@ ${user.trimEnd()}
     if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
   } else {
     const dir = mindDir(baseName);
-    if (!existsSync8(dir)) return c.json({ error: "Mind directory missing" }, 404);
+    if (!existsSync10(dir)) return c.json({ error: "Mind directory missing" }, 404);
   }
   if (getMindManager().isRunning(name)) {
     return c.json({ error: "Mind already running" }, 409);
   }
   try {
-    await startMindFull(name, baseName, variantName);
+    await startMindFull(name);
     return c.json({ ok: true });
   } catch (err) {
     return c.json({ error: err instanceof Error ? err.message : "Failed to start mind" }, 500);
@@ -2951,7 +3270,7 @@ ${user.trimEnd()}
     if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
   } else {
     const dir = mindDir(baseName);
-    if (!existsSync8(dir)) return c.json({ error: "Mind directory missing" }, 404);
+    if (!existsSync10(dir)) return c.json({ error: "Mind directory missing" }, 404);
   }
   let context;
   const contentType = c.req.header("content-type");
@@ -2960,17 +3279,13 @@ ${user.trimEnd()}
       const body = await c.req.json();
       if (body?.context) context = body.context;
     } catch (err) {
-      console.error(`[daemon] failed to parse restart context for ${name}:`, err);
+      logger_default.error(`failed to parse restart context for ${name}`, logger_default.errorData(err));
     }
   }
   const manager = getMindManager();
   try {
     if (manager.isRunning(name)) {
-      if (!variantName) {
-        await getConnectorManager().stopConnectors(baseName);
-        getTokenBudget().removeBudget(baseName);
-      }
-      await manager.stopMind(name);
+      await stopMindFull(name);
     }
     if (context?.type === "merge" && context.name && !variantName) {
       const mergeVariantName = String(context.name);
@@ -2978,11 +3293,11 @@ ${user.trimEnd()}
       if (branchErr) {
         return c.json({ error: `Invalid variant name: ${branchErr}` }, 400);
       }
-      console.error(`[daemon] merging variant for ${baseName}: ${mergeVariantName}`);
+      logger_default.error(`merging variant for ${baseName}: ${mergeVariantName}`);
       const variant = findVariant(baseName, mergeVariantName);
       if (variant) {
         const projectRoot = mindDir(baseName);
-        if (existsSync8(variant.path)) {
+        if (existsSync10(variant.path)) {
           const status = (await gitExec(["status", "--porcelain"], { cwd: variant.path })).trim();
           if (status) {
             try {
@@ -2991,9 +3306,9 @@ ${user.trimEnd()}
                 cwd: variant.path
               });
             } catch (e) {
-              console.error(
-                `[daemon] failed to auto-commit variant worktree for ${baseName}:`,
-                e
+              logger_default.error(
+                `failed to auto-commit variant worktree for ${baseName}`,
+                logger_default.errorData(e)
               );
             }
           }
@@ -3006,11 +3321,11 @@ ${user.trimEnd()}
               cwd: projectRoot
             });
           } catch (e) {
-            console.error(`[daemon] failed to auto-commit main worktree for ${baseName}:`, e);
+            logger_default.error(`failed to auto-commit main worktree for ${baseName}`, logger_default.errorData(e));
           }
         }
         await gitExec(["merge", variant.branch], { cwd: projectRoot });
-        if (existsSync8(variant.path)) {
+        if (existsSync10(variant.path)) {
           try {
             await gitExec(["worktree", "remove", "--force", variant.path], {
               cwd: projectRoot
@@ -3027,7 +3342,7 @@ ${user.trimEnd()}
         try {
           await npmInstallAsMind(projectRoot, baseName);
         } catch (e) {
-          console.error(`[daemon] npm install failed after merge for ${baseName}:`, e);
+          logger_default.error(`npm install failed after merge for ${baseName}`, logger_default.errorData(e));
         }
       }
     }
@@ -3036,18 +3351,18 @@ ${user.trimEnd()}
     }
     if (context?.type === "sprouted" && !variantName) {
       try {
-        const db2 = await getDb();
-        const activeConvs = await db2.select({ id: conversations.id }).from(conversations).where(eq4(conversations.mind_name, baseName)).all();
+        const db = await getDb();
+        const activeConvs = await db.select({ id: conversations.id }).from(conversations).where(eq4(conversations.mind_name, baseName)).all();
         for (const conv of activeConvs) {
           await addMessage(conv.id, "assistant", "system", [
             { type: "text", text: "[seed has sprouted]" }
           ]);
         }
       } catch (err) {
-        console.error(`[daemon] failed to inject sprouted message for ${baseName}:`, err);
+        logger_default.error(`failed to inject sprouted message for ${baseName}`, logger_default.errorData(err));
       }
     }
-    await startMindFull(name, baseName, variantName);
+    await startMindFull(name);
     return c.json({ ok: true });
   } catch (err) {
     return c.json({ error: err instanceof Error ? err.message : "Failed to restart mind" }, 500);
@@ -3066,12 +3381,7 @@ ${user.trimEnd()}
     return c.json({ error: "Mind is not running" }, 409);
   }
   try {
-    if (!variantName) {
-      await getConnectorManager().stopConnectors(baseName);
-      getScheduler().unloadSchedules(baseName);
-      getTokenBudget().removeBudget(baseName);
-    }
-    await manager.stopMind(name);
+    await stopMindFull(name);
     return c.json({ ok: true });
   } catch (err) {
     return c.json({ error: err instanceof Error ? err.message : "Failed to stop mind" }, 500);
@@ -3093,19 +3403,22 @@ ${user.trimEnd()}
   const force = c.req.query("force") === "true";
   const manager = getMindManager();
   if (manager.isRunning(name)) {
-    await getConnectorManager().stopConnectors(name);
-    getTokenBudget().removeBudget(name);
-    await manager.stopMind(name);
+    await stopMindFull(name);
   }
   removeAllVariants(name);
+  try {
+    await removeSharedWorktree(name, dir);
+  } catch (err) {
+    logger_default.warn(`failed to clean up shared worktree for ${name}`, logger_default.errorData(err));
+  }
   removeMind(name);
   await deleteMindUser2(name);
   const state = stateDir(name);
-  if (existsSync8(state)) {
-    rmSync(state, { recursive: true, force: true });
+  if (existsSync10(state)) {
+    rmSync2(state, { recursive: true, force: true });
   }
-  if (force && existsSync8(dir)) {
-    rmSync(dir, { recursive: true, force: true });
+  if (force && existsSync10(dir)) {
+    rmSync2(dir, { recursive: true, force: true });
     deleteMindUser(name);
   }
   return c.json({ ok: true });
@@ -3114,17 +3427,17 @@ ${user.trimEnd()}
   const entry = findMind(mindName);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const dir = mindDir(mindName);
-  if (!existsSync8(dir)) return c.json({ error: "Mind directory missing" }, 404);
+  if (!existsSync10(dir)) return c.json({ error: "Mind directory missing" }, 404);
   let body = {};
   try {
     body = await c.req.json();
   } catch {
   }
-  const template = body.template ?? "claude";
+  const template = body.template ?? entry.template ?? "claude";
   const UPGRADE_VARIANT = "upgrade";
   if (body.continue) {
-    const worktreeDir2 = resolve11(dir, ".variants", UPGRADE_VARIANT);
-    if (!existsSync8(worktreeDir2)) {
+    const worktreeDir2 = resolve13(dir, ".variants", UPGRADE_VARIANT);
+    if (!existsSync10(worktreeDir2)) {
       return c.json({ error: "No upgrade in progress" }, 400);
     }
     const status = await gitExec(["status", "--porcelain"], { cwd: worktreeDir2 });
@@ -3173,9 +3486,9 @@ ${user.trimEnd()}
       try {
         chownMindDir(dir, mindName);
       } catch (chownErr) {
-        console.error(
-          `[daemon] failed to fix ownership during upgrade cleanup for ${mindName}:`,
-          chownErr
+        logger_default.error(
+          `failed to fix ownership during upgrade cleanup for ${mindName}`,
+          logger_default.errorData(chownErr)
         );
       }
       return c.json(
@@ -3184,8 +3497,8 @@ ${user.trimEnd()}
       );
     }
   }
-  const worktreeDir = resolve11(dir, ".variants", UPGRADE_VARIANT);
-  if (existsSync8(worktreeDir)) {
+  const worktreeDir = resolve13(dir, ".variants", UPGRADE_VARIANT);
+  if (existsSync10(worktreeDir)) {
     return c.json(
       { error: "Upgrade variant already exists. Use continue or delete it first." },
       409
@@ -3196,10 +3509,20 @@ ${user.trimEnd()}
     await gitExec(["branch", "-D", UPGRADE_VARIANT], { cwd: dir });
   } catch {
   }
+  if (!existsSync10(resolve13(dir, "home", "shared"))) {
+    try {
+      await addSharedWorktree(mindName, dir);
+    } catch (err) {
+      logger_default.warn(
+        `failed to add shared worktree during upgrade for ${mindName}`,
+        logger_default.errorData(err)
+      );
+    }
+  }
   await updateTemplateBranch(dir, template, mindName);
-  const parentDir = resolve11(dir, ".variants");
-  if (!existsSync8(parentDir)) {
-    mkdirSync4(parentDir, { recursive: true });
+  const parentDir = resolve13(dir, ".variants");
+  if (!existsSync10(parentDir)) {
+    mkdirSync7(parentDir, { recursive: true });
   }
   await gitExec(["worktree", "add", "-b", UPGRADE_VARIANT, worktreeDir], { cwd: dir });
   const hasConflicts = await mergeTemplateBranch(worktreeDir);
@@ -3245,9 +3568,9 @@ ${user.trimEnd()}
     try {
       chownMindDir(dir, mindName);
     } catch (chownErr) {
-      console.error(
-        `[daemon] failed to fix ownership during upgrade cleanup for ${mindName}:`,
-        chownErr
+      logger_default.error(
+        `failed to fix ownership during upgrade cleanup for ${mindName}`,
+        logger_default.errorData(chownErr)
       );
     }
     return c.json(
@@ -3260,11 +3583,9 @@ ${user.trimEnd()}
   const [baseName, variantName] = name.split("@", 2);
   const entry = findMind(baseName);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  let port = entry.port;
   if (variantName) {
     const variant = findVariant(baseName, variantName);
     if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
-    port = variant.port;
   }
   if (!getMindManager().isRunning(name)) {
     return c.json({ error: "Mind is not running" }, 409);
@@ -3274,15 +3595,15 @@ ${user.trimEnd()}
   try {
     parsed = JSON.parse(body);
   } catch (err) {
-    console.error(`[daemon] failed to parse message body for ${baseName}:`, err);
+    logger_default.error(`failed to parse message body for ${baseName}`, logger_default.errorData(err));
   }
   const channel = parsed?.channel ?? "unknown";
-  const db2 = await getDb();
+  const db = await getDb();
   if (parsed) {
     try {
       const sender2 = parsed.sender ?? null;
       const content = extractTextContent(parsed.content);
-      await db2.insert(mindHistory).values({
+      await db.insert(mindHistory).values({
         mind: baseName,
         type: "inbound",
         channel,
@@ -3290,7 +3611,7 @@ ${user.trimEnd()}
         content
       });
     } catch (err) {
-      console.error(`[daemon] failed to persist inbound message for ${baseName}:`, err);
+      logger_default.error(`failed to persist inbound message for ${baseName}`, logger_default.errorData(err));
     }
   }
   const budget = getTokenBudget();
@@ -3304,16 +3625,31 @@ ${user.trimEnd()}
     });
     return c.json({ error: "Token budget exceeded \u2014 message queued for next period" }, 429);
   }
+  if (!parsed) return c.json({ error: "Invalid JSON" }, 400);
   const typingMap = getTypingMap();
-  const sender = parsed?.sender ?? "";
+  const sender = parsed.sender ?? "";
   if (sender) typingMap.delete(channel, sender);
   const currentlyTyping = typingMap.get(channel).filter((s) => s !== baseName);
-  let forwardBody = body;
-  if (parsed && currentlyTyping.length > 0) {
+  if (currentlyTyping.length > 0) {
     parsed.typing = currentlyTyping;
-    forwardBody = JSON.stringify(parsed);
   }
-  if (budgetStatus === "warning" && parsed) {
+  if (sender && findMind(sender)) {
+    try {
+      const senderDir = mindDir(sender);
+      const senderPrivateKey = getPrivateKey(senderDir);
+      const senderPublicKey = getPublicKey(senderDir);
+      if (senderPrivateKey && senderPublicKey) {
+        const textContent = extractTextContent(parsed.content);
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        parsed.signature = signMessage(senderPrivateKey, textContent, timestamp);
+        parsed.signatureTimestamp = timestamp;
+        parsed.signerFingerprint = getFingerprint(senderPublicKey);
+      }
+    } catch (err) {
+      logger_default.warn(`failed to sign message from ${sender}`, { error: err.message });
+    }
+  }
+  if (budgetStatus === "warning") {
     const usage = budget.getUsage(baseName);
     const pct = usage?.percentUsed ?? 80;
     const warningText = `
@@ -3324,12 +3660,11 @@ ${user.trimEnd()}
       parsed.content = [...parsed.content, { type: "text", text: warningText }];
     }
     budget.acknowledgeWarning(baseName);
-    forwardBody = JSON.stringify(parsed);
   }
   const seedEntry = findMind(baseName);
-  if (seedEntry?.stage === "seed" && parsed) {
+  if (seedEntry?.stage === "seed") {
     try {
-      const countResult = await db2.select({ count: sql3`count(*)` }).from(mindHistory).where(eq4(mindHistory.mind, baseName));
+      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.]";
@@ -3338,27 +3673,29 @@ ${user.trimEnd()}
         } else if (Array.isArray(parsed.content)) {
           parsed.content = [...parsed.content, { type: "text", text: nudge }];
         }
-        forwardBody = JSON.stringify(parsed);
       }
     } catch (err) {
-      console.error(`[daemon] failed to check seed message count for ${baseName}:`, err);
-    }
+      logger_default.error(`failed to check seed message count for ${baseName}`, logger_default.errorData(err));
+    }
+  }
+  const deliveryPayload = {
+    channel: parsed.channel,
+    sender: parsed.sender ?? null,
+    content: parsed.content,
+    conversationId: parsed.conversationId ?? void 0,
+    typing: parsed.typing,
+    platform: parsed.platform ?? void 0,
+    isDM: parsed.isDM ?? void 0,
+    participants: parsed.participants ?? void 0,
+    participantCount: parsed.participantCount ?? void 0
+  };
+  if (parsed.signature) {
+    deliveryPayload.signature = parsed.signature;
+    deliveryPayload.signatureTimestamp = parsed.signatureTimestamp;
+    deliveryPayload.signerFingerprint = parsed.signerFingerprint;
   }
-  typingMap.set(channel, baseName, { persistent: true });
-  const conversationId = parsed?.conversationId ?? null;
-  if (conversationId) typingMap.set(`volute:${conversationId}`, baseName, { persistent: true });
-  fetch(`http://127.0.0.1:${port}/message`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: forwardBody
-  }).then(async (res) => {
-    if (!res.ok) {
-      const text2 = await res.text().catch(() => "");
-      console.error(`[daemon] mind ${name} responded with ${res.status}: ${text2}`);
-    }
-  }).catch((err) => {
-    console.error(`[daemon] mind ${name} unreachable on port ${port}:`, err);
-    typingMap.delete(channel, baseName);
+  getDeliveryManager().routeAndDeliver(name, deliveryPayload).catch((err) => {
+    logger_default.error(`delivery failed for ${name}`, logger_default.errorData(err));
   });
   return c.json({ ok: true });
 }).get("/:name/budget", async (c) => {
@@ -3367,6 +3704,19 @@ ${user.trimEnd()}
   const usage = getTokenBudget().getUsage(baseName);
   if (!usage) return c.json({ error: "No budget configured" }, 404);
   return c.json(usage);
+}).get("/:name/delivery/pending", async (c) => {
+  const name = c.req.param("name");
+  const [baseName] = name.split("@", 2);
+  try {
+    const pending = await getDeliveryManager().getPending(baseName);
+    return c.json(pending);
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("not initialized")) {
+      return c.json([]);
+    }
+    logger_default.error(`failed to get pending deliveries for ${baseName}`, logger_default.errorData(err));
+    return c.json({ error: "Failed to retrieve pending messages" }, 500);
+  }
 }).post("/:name/events", async (c) => {
   const name = c.req.param("name");
   const [baseName] = name.split("@", 2);
@@ -3379,9 +3729,9 @@ ${user.trimEnd()}
   if (!body.type) {
     return c.json({ error: "type required" }, 400);
   }
-  const db2 = await getDb();
+  const db = await getDb();
   try {
-    await db2.insert(mindHistory).values({
+    await db.insert(mindHistory).values({
       mind: baseName,
       type: body.type,
       session: body.session ?? null,
@@ -3391,7 +3741,7 @@ ${user.trimEnd()}
       metadata: body.metadata ? JSON.stringify(body.metadata) : null
     });
   } catch (err) {
-    console.error(`[daemon] failed to persist event for ${baseName}:`, err);
+    logger_default.error(`failed to persist event for ${baseName}`, logger_default.errorData(err));
   }
   publish2(baseName, {
     mind: baseName,
@@ -3402,12 +3752,22 @@ ${user.trimEnd()}
     content: body.content,
     metadata: body.metadata
   });
+  if ((body.type === "text" || body.type === "outbound") && body.channel) {
+    getTypingMap().delete(body.channel, baseName);
+  }
   if (body.type === "done") {
     if (body.channel) {
       getTypingMap().delete(body.channel, baseName);
     } else {
       getTypingMap().deleteSender(baseName);
     }
+    try {
+      getDeliveryManager().sessionDone(baseName, body.session);
+    } catch (err) {
+      if (!(err instanceof Error && err.message.includes("not initialized"))) {
+        logger_default.error(`delivery manager sessionDone failed for ${baseName}`, logger_default.errorData(err));
+      }
+    }
   }
   if (body.type === "usage" && body.metadata) {
     const inputTokens = body.metadata.input_tokens ?? 0;
@@ -3465,9 +3825,9 @@ ${user.trimEnd()}
   if (!body.channel || !body.content) {
     return c.json({ error: "channel and content required" }, 400);
   }
-  const db2 = await getDb();
+  const db = await getDb();
   try {
-    await db2.insert(mindHistory).values({
+    await db.insert(mindHistory).values({
       mind: baseName,
       type: "outbound",
       channel: body.channel,
@@ -3475,25 +3835,25 @@ ${user.trimEnd()}
       content: body.content
     });
   } catch (err) {
-    console.error(`[daemon] failed to persist external send for ${baseName}:`, err);
+    logger_default.error(`failed to persist external send for ${baseName}`, logger_default.errorData(err));
     return c.json({ error: "Failed to persist" }, 500);
   }
   return c.json({ ok: true });
 }).get("/:name/history/sessions", async (c) => {
   const name = c.req.param("name");
-  const db2 = await getDb();
-  const rows = await db2.select({
+  const db = await getDb();
+  const rows = await db.select({
     session: mindHistory.session,
-    started_at: sql3`MIN(${mindHistory.created_at})`,
-    event_count: sql3`COUNT(*)`,
-    message_count: sql3`SUM(CASE WHEN ${mindHistory.type} IN ('inbound','outbound') THEN 1 ELSE 0 END)`,
-    tool_count: sql3`SUM(CASE WHEN ${mindHistory.type}='tool_use' THEN 1 ELSE 0 END)`
-  }).from(mindHistory).where(and3(eq4(mindHistory.mind, name), sql3`${mindHistory.session} IS NOT NULL`)).groupBy(mindHistory.session).orderBy(sql3`MIN(${mindHistory.created_at}) DESC`);
+    started_at: sql2`MIN(${mindHistory.created_at})`,
+    event_count: sql2`COUNT(*)`,
+    message_count: sql2`SUM(CASE WHEN ${mindHistory.type} IN ('inbound','outbound') THEN 1 ELSE 0 END)`,
+    tool_count: sql2`SUM(CASE WHEN ${mindHistory.type}='tool_use' THEN 1 ELSE 0 END)`
+  }).from(mindHistory).where(and3(eq4(mindHistory.mind, name), sql2`${mindHistory.session} IS NOT NULL`)).groupBy(mindHistory.session).orderBy(sql2`MIN(${mindHistory.created_at}) DESC`);
   return c.json(rows);
 }).get("/:name/history/channels", async (c) => {
   const name = c.req.param("name");
-  const db2 = await getDb();
-  const rows = await db2.selectDistinct({ channel: mindHistory.channel }).from(mindHistory).where(eq4(mindHistory.mind, name));
+  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", async (c) => {
   const name = c.req.param("name");
@@ -3502,7 +3862,7 @@ ${user.trimEnd()}
   const full = c.req.query("full") === "true";
   const limit = Math.min(Math.max(parseInt(c.req.query("limit") ?? "50", 10) || 50, 1), 200);
   const offset = Math.max(parseInt(c.req.query("offset") ?? "0", 10) || 0, 0);
-  const db2 = await getDb();
+  const db = await getDb();
   const conditions = [eq4(mindHistory.mind, name)];
   if (channel) {
     conditions.push(eq4(mindHistory.channel, channel));
@@ -3511,17 +3871,17 @@ ${user.trimEnd()}
     conditions.push(eq4(mindHistory.session, session));
   }
   if (!full) {
-    conditions.push(sql3`${mindHistory.type} IN ('inbound', 'outbound')`);
+    conditions.push(sql2`${mindHistory.type} IN ('inbound', 'outbound')`);
   }
-  const rows = await db2.select().from(mindHistory).where(and3(...conditions)).orderBy(desc2(mindHistory.created_at)).limit(limit).offset(offset);
+  const rows = await db.select().from(mindHistory).where(and3(...conditions)).orderBy(desc2(mindHistory.created_at)).limit(limit).offset(offset);
   return c.json(rows);
 });
-var minds_default = app7;
+var minds_default = app9;
 
 // src/web/api/pages.ts
 import { readFile as readFile2, stat } from "fs/promises";
-import { extname, resolve as resolve12 } from "path";
-import { Hono as Hono8 } from "hono";
+import { extname, resolve as resolve14 } from "path";
+import { Hono as Hono10 } from "hono";
 var MIME_TYPES = {
   ".html": "text/html",
   ".js": "application/javascript",
@@ -3538,16 +3898,16 @@ var MIME_TYPES = {
   ".txt": "text/plain",
   ".xml": "application/xml"
 };
-var app8 = new Hono8().get("/:name/*", async (c) => {
+var app10 = new Hono10().get("/:name/*", async (c) => {
   const name = c.req.param("name");
   if (!findMind(name)) return c.text("Not found", 404);
-  const pagesRoot = resolve12(mindDir(name), "home", "pages");
+  const pagesRoot = resolve14(mindDir(name), "home", "pages");
   const wildcard = c.req.path.replace(`/pages/${name}`, "") || "/";
-  const requestedPath = resolve12(pagesRoot, wildcard.slice(1));
+  const requestedPath = resolve14(pagesRoot, wildcard.slice(1));
   if (!requestedPath.startsWith(pagesRoot)) return c.text("Forbidden", 403);
   let fileStat = await stat(requestedPath).catch(() => null);
   if (fileStat?.isDirectory()) {
-    const indexPath = resolve12(requestedPath, "index.html");
+    const indexPath = resolve14(requestedPath, "index.html");
     fileStat = await stat(indexPath).catch(() => null);
     if (fileStat?.isFile()) {
       const body = await readFile2(indexPath);
@@ -3563,10 +3923,61 @@ var app8 = new Hono8().get("/:name/*", async (c) => {
   }
   return c.text("Not found", 404);
 });
-var pages_default = app8;
+var pages_default = app10;
+
+// src/web/api/prompts.ts
+import { zValidator as zValidator4 } from "@hono/zod-validator";
+import { eq as eq5, sql as sql3 } from "drizzle-orm";
+import { Hono as Hono11 } from "hono";
+import { z as z4 } from "zod";
+var app11 = new Hono11().get("/", async (c) => {
+  let rows;
+  try {
+    const db = await getDb();
+    rows = await db.select().from(systemPrompts).all();
+  } catch (err) {
+    console.error("[prompts] failed to query system_prompts:", err);
+    return c.json({ error: "Failed to load prompts from database" }, 500);
+  }
+  const customMap = new Map(rows.map((r) => [r.key, r.content]));
+  const prompts = PROMPT_KEYS.map((key) => {
+    const meta = PROMPT_DEFAULTS[key];
+    const custom = customMap.get(key);
+    return {
+      key,
+      content: custom ?? meta.content,
+      description: meta.description,
+      variables: meta.variables,
+      isCustom: custom !== void 0,
+      category: meta.category
+    };
+  });
+  return c.json(prompts);
+}).put("/:key", requireAdmin, zValidator4("json", z4.object({ content: z4.string() })), async (c) => {
+  const key = c.req.param("key");
+  if (!PROMPT_KEYS.includes(key)) {
+    return c.json({ error: "Unknown prompt key" }, 404);
+  }
+  const { content } = c.req.valid("json");
+  const db = await getDb();
+  await db.insert(systemPrompts).values({ key, content, updated_at: sql3`(datetime('now'))` }).onConflictDoUpdate({
+    target: systemPrompts.key,
+    set: { content, updated_at: sql3`(datetime('now'))` }
+  });
+  return c.json({ ok: true });
+}).delete("/:key", requireAdmin, async (c) => {
+  const key = c.req.param("key");
+  if (!PROMPT_KEYS.includes(key)) {
+    return c.json({ error: "Unknown prompt key" }, 404);
+  }
+  const db = await getDb();
+  await db.delete(systemPrompts).where(eq5(systemPrompts.key, key));
+  return c.json({ ok: true });
+});
+var prompts_default = app11;
 
 // src/web/api/schedules.ts
-import { Hono as Hono9 } from "hono";
+import { Hono as Hono12 } from "hono";
 function readSchedules(name) {
   return readVoluteConfig(mindDir(name))?.schedules ?? [];
 }
@@ -3577,7 +3988,7 @@ function writeSchedules(name, schedules) {
   writeVoluteConfig(dir, config);
   getScheduler().loadSchedules(name);
 }
-var app9 = new Hono9().get("/:name/schedules", (c) => {
+var app12 = new Hono12().get("/:name/schedules", (c) => {
   const name = c.req.param("name");
   if (!findMind(name)) return c.json({ error: "Mind not found" }, 404);
   return c.json(readSchedules(name));
@@ -3648,12 +4059,138 @@ var app9 = new Hono9().get("/:name/schedules", (c) => {
     return c.json({ error: "Failed to reach mind" }, 502);
   }
 });
-var schedules_default = app9;
+var schedules_default = app12;
+
+// src/web/api/shared.ts
+import { Hono as Hono13 } from "hono";
+var app13 = new Hono13().post("/:name/shared/merge", requireAdmin, async (c) => {
+  const name = c.req.param("name");
+  const entry = findMind(name);
+  if (!entry) return c.json({ error: "Mind not found" }, 404);
+  let body;
+  try {
+    body = await c.req.json();
+  } catch {
+    return c.json({ error: "Invalid JSON in request body" }, 400);
+  }
+  const message = body.message || `shared: merge from ${name}`;
+  try {
+    const result = await sharedMerge(name, mindDir(name), message);
+    return c.json(result);
+  } catch (err) {
+    return c.json({ error: err instanceof Error ? err.message : "Merge failed" }, 500);
+  }
+}).post("/:name/shared/pull", requireAdmin, async (c) => {
+  const name = c.req.param("name");
+  const entry = findMind(name);
+  if (!entry) return c.json({ error: "Mind not found" }, 404);
+  try {
+    const result = await sharedPull(name, mindDir(name));
+    return c.json(result);
+  } catch (err) {
+    return c.json({ error: err instanceof Error ? err.message : "Pull failed" }, 500);
+  }
+}).get("/:name/shared/log", async (c) => {
+  const name = c.req.param("name");
+  const entry = findMind(name);
+  if (!entry) return c.json({ error: "Mind not found" }, 404);
+  const limit = parseInt(c.req.query("limit") ?? "20", 10) || 20;
+  try {
+    const log2 = await sharedLog(limit);
+    return c.text(log2);
+  } catch (err) {
+    return c.json({ error: err instanceof Error ? err.message : "Failed to read log" }, 500);
+  }
+}).get("/:name/shared/status", async (c) => {
+  const name = c.req.param("name");
+  const entry = findMind(name);
+  if (!entry) return c.json({ error: "Mind not found" }, 404);
+  try {
+    const status = await sharedStatus(name);
+    return c.text(status);
+  } catch (err) {
+    return c.json({ error: err instanceof Error ? err.message : "Failed to get status" }, 500);
+  }
+});
+var shared_default = app13;
+
+// src/web/api/skills.ts
+import { existsSync as existsSync11, mkdtempSync, readdirSync as readdirSync5, rmSync as rmSync3 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join3, resolve as resolve15 } from "path";
+import AdmZip from "adm-zip";
+import { Hono as Hono14 } from "hono";
+var app14 = new Hono14().get("/", async (c) => {
+  const skills = await listSharedSkills();
+  return c.json(skills);
+}).get("/:id", async (c) => {
+  const id = c.req.param("id");
+  const skill = await getSharedSkill(id);
+  if (!skill) return c.json({ error: "Skill not found" }, 404);
+  const dir = join3(sharedSkillsDir(), id);
+  const files = listFilesRecursive(dir);
+  return c.json({ ...skill, files });
+}).post("/upload", requireAdmin, async (c) => {
+  const body = await c.req.parseBody();
+  const file = body.file;
+  if (!file || !(file instanceof File)) {
+    return c.json({ error: "No file uploaded" }, 400);
+  }
+  if (!file.name.endsWith(".zip")) {
+    return c.json({ error: "Only .zip files are accepted" }, 400);
+  }
+  const buffer = Buffer.from(await file.arrayBuffer());
+  const tmpDir = mkdtempSync(join3(tmpdir2(), "volute-skill-upload-"));
+  try {
+    const zip = new AdmZip(buffer);
+    for (const entry of zip.getEntries()) {
+      const target = resolve15(tmpDir, entry.entryName);
+      if (!target.startsWith(tmpDir)) {
+        return c.json({ error: "Invalid zip: paths must not escape archive" }, 400);
+      }
+    }
+    zip.extractAllTo(tmpDir, true);
+    let skillDir = null;
+    if (existsSync11(join3(tmpDir, "SKILL.md"))) {
+      skillDir = tmpDir;
+    } else {
+      const entries = readdirSync5(tmpDir, { withFileTypes: true }).filter((e) => e.isDirectory());
+      for (const entry of entries) {
+        if (existsSync11(join3(tmpDir, entry.name, "SKILL.md"))) {
+          skillDir = join3(tmpDir, entry.name);
+          break;
+        }
+      }
+    }
+    if (!skillDir) {
+      return c.json({ error: "No SKILL.md found in zip (checked root and one level deep)" }, 400);
+    }
+    const skill = await importSkillFromDir(skillDir, "upload");
+    return c.json(skill);
+  } catch (e) {
+    if (e instanceof Error && e.message.includes("Invalid skill ID")) {
+      return c.json({ error: e.message }, 400);
+    }
+    throw e;
+  } finally {
+    rmSync3(tmpDir, { recursive: true, force: true });
+  }
+}).delete("/:id", requireAdmin, async (c) => {
+  const id = c.req.param("id");
+  try {
+    await removeSharedSkill(id);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return c.json({ error: msg }, 404);
+  }
+  return c.json({ ok: true });
+});
+var skills_default = app14;
 
 // src/web/api/system.ts
-import { Hono as Hono10 } from "hono";
+import { Hono as Hono15 } from "hono";
 import { streamSSE as streamSSE2 } from "hono/streaming";
-var app10 = new Hono10().post("/restart", requireAdmin, (c) => {
+var app15 = new Hono15().post("/restart", requireAdmin, (c) => {
   setTimeout(() => process.exit(1), 200);
   return c.json({ ok: true });
 }).post("/stop", requireAdmin, (c) => {
@@ -3670,10 +4207,10 @@ var app10 = new Hono10().post("/restart", requireAdmin, (c) => {
       stream.writeSSE({ data: JSON.stringify(entry) }).catch(() => {
       });
     });
-    await new Promise((resolve18) => {
+    await new Promise((resolve20) => {
       stream.onAbort(() => {
         unsubscribe();
-        resolve18();
+        resolve20();
       });
     });
   });
@@ -3681,18 +4218,18 @@ var app10 = new Hono10().post("/restart", requireAdmin, (c) => {
   const config = readSystemsConfig();
   return c.json({ system: config?.system ?? null });
 });
-var system_default = app10;
+var system_default = app15;
 
 // src/web/api/typing.ts
-import { zValidator as zValidator3 } from "@hono/zod-validator";
-import { Hono as Hono11 } from "hono";
-import { z as z3 } from "zod";
-var typingSchema = z3.object({
-  channel: z3.string().min(1),
-  sender: z3.string().min(1),
-  active: z3.boolean()
+import { zValidator as zValidator5 } from "@hono/zod-validator";
+import { Hono as Hono16 } from "hono";
+import { z as z5 } from "zod";
+var typingSchema = z5.object({
+  channel: z5.string().min(1),
+  sender: z5.string().min(1),
+  active: z5.boolean()
 });
-var app11 = new Hono11().post("/:name/typing", zValidator3("json", typingSchema), (c) => {
+var app16 = new Hono16().post("/:name/typing", zValidator5("json", typingSchema), (c) => {
   const { channel, sender, active } = c.req.valid("json");
   const map = getTypingMap();
   if (active) {
@@ -3709,13 +4246,13 @@ var app11 = new Hono11().post("/:name/typing", zValidator3("json", typingSchema)
   const map = getTypingMap();
   return c.json({ typing: map.get(channel) });
 });
-var typing_default = app11;
+var typing_default = app16;
 
 // src/web/api/update.ts
 import { spawn as spawn3 } from "child_process";
-import { Hono as Hono12 } from "hono";
+import { Hono as Hono17 } from "hono";
 var bin;
-var app12 = new Hono12().get("/update", async (c) => {
+var app17 = new Hono17().get("/update", async (c) => {
   const result = await checkForUpdate();
   return c.json(result);
 }).post("/update", requireAdmin, async (c) => {
@@ -3730,19 +4267,19 @@ var app12 = new Hono12().get("/update", async (c) => {
   child.unref();
   return c.json({ ok: true, message: "Updating..." });
 });
-var update_default = app12;
+var update_default = app17;
 
 // src/web/api/variants.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "fs";
-import { resolve as resolve14 } from "path";
-import { Hono as Hono13 } from "hono";
+import { existsSync as existsSync12, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
+import { resolve as resolve17 } from "path";
+import { Hono as Hono18 } from "hono";
 
 // src/lib/spawn-server.ts
 import { spawn as spawn4 } from "child_process";
-import { closeSync, mkdirSync as mkdirSync5, openSync, readFileSync as readFileSync7 } from "fs";
-import { resolve as resolve13 } from "path";
+import { closeSync, mkdirSync as mkdirSync8, openSync, readFileSync as readFileSync10 } from "fs";
+import { resolve as resolve16 } from "path";
 function tsxBin(cwd) {
-  return resolve13(cwd, "node_modules", ".bin", "tsx");
+  return resolve16(cwd, "node_modules", ".bin", "tsx");
 }
 function spawnServer(cwd, port, options) {
   if (options?.detached) {
@@ -3755,31 +4292,31 @@ function spawnAttached(cwd, port) {
     cwd,
     stdio: ["ignore", "pipe", "pipe"]
   });
-  return new Promise((resolve18) => {
-    const timeout = setTimeout(() => resolve18(null), 3e4);
+  return new Promise((resolve20) => {
+    const timeout = setTimeout(() => resolve20(null), 3e4);
     function checkOutput(data) {
       const match = data.toString().match(/listening on :(\d+)/);
       if (match) {
         clearTimeout(timeout);
-        resolve18({ child, actualPort: parseInt(match[1], 10) });
+        resolve20({ child, actualPort: parseInt(match[1], 10) });
       }
     }
     child.stdout?.on("data", checkOutput);
     child.stderr?.on("data", checkOutput);
     child.on("error", () => {
       clearTimeout(timeout);
-      resolve18(null);
+      resolve20(null);
     });
     child.on("exit", () => {
       clearTimeout(timeout);
-      resolve18(null);
+      resolve20(null);
     });
   });
 }
 function spawnDetached(cwd, port, logDir) {
-  const logsDir = logDir ?? resolve13(cwd, ".volute", "logs");
-  mkdirSync5(logsDir, { recursive: true });
-  const logPath = resolve13(logsDir, "mind.log");
+  const logsDir = logDir ?? resolve16(cwd, ".mind", "logs");
+  mkdirSync8(logsDir, { recursive: true });
+  const logPath = resolve16(logsDir, "mind.log");
   const logFd = openSync(logPath, "a");
   const child = spawn4(tsxBin(cwd), ["src/server.ts", "--port", String(port)], {
     cwd,
@@ -3799,7 +4336,7 @@ function spawnDetached(cwd, port, logDir) {
     }
     const interval = setInterval(() => {
       try {
-        const content = readFileSync7(logPath, "utf-8");
+        const content = readFileSync10(logPath, "utf-8");
         const match = content.match(/listening on :(\d+)/);
         if (match) {
           finish({ child, actualPort: parseInt(match[1], 10) });
@@ -3814,7 +4351,7 @@ function spawnDetached(cwd, port, logDir) {
 }
 
 // src/lib/verify.ts
-async function verify(port) {
+async function verify2(port) {
   const health = await checkHealth(port);
   if (!health.ok) {
     console.error("  Health check: failed");
@@ -3851,7 +4388,7 @@ async function verify(port) {
 }
 
 // src/web/api/variants.ts
-var app13 = new Hono13().get("/:name/variants", async (c) => {
+var app18 = new Hono18().get("/:name/variants", async (c) => {
   const name = c.req.param("name");
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
@@ -3881,11 +4418,11 @@ var app13 = new Hono13().get("/:name/variants", async (c) => {
   const err = validateBranchName(variantName);
   if (err) return c.json({ error: err }, 400);
   const projectRoot = mindDir(mindName);
-  const variantDir = resolve14(projectRoot, ".variants", variantName);
-  if (existsSync9(variantDir)) {
+  const variantDir = resolve17(projectRoot, ".variants", variantName);
+  if (existsSync12(variantDir)) {
     return c.json({ error: `Variant directory already exists: ${variantDir}` }, 409);
   }
-  mkdirSync6(resolve14(projectRoot, ".variants"), { recursive: true });
+  mkdirSync9(resolve17(projectRoot, ".variants"), { recursive: true });
   try {
     await gitExec(["worktree", "add", "-b", variantName, variantDir], { cwd: projectRoot });
   } catch (e) {
@@ -3898,7 +4435,7 @@ var app13 = new Hono13().get("/:name/variants", async (c) => {
       const [cmd, args] = wrapForIsolation("npm", ["install"], mindName);
       await exec(cmd, args, {
         cwd: variantDir,
-        env: { ...process.env, HOME: resolve14(variantDir, "home") }
+        env: { ...process.env, HOME: resolve17(variantDir, "home") }
       });
     } else {
       await exec("npm", ["install"], { cwd: variantDir });
@@ -3908,7 +4445,7 @@ var app13 = new Hono13().get("/:name/variants", async (c) => {
     return c.json({ error: `npm install failed: ${msg}` }, 500);
   }
   if (body.soul) {
-    writeFileSync6(resolve14(variantDir, "home/SOUL.md"), body.soul);
+    writeFileSync9(resolve17(variantDir, "home/SOUL.md"), body.soul);
   }
   const variantPort = body.port ?? nextPort();
   const variant = {
@@ -3946,7 +4483,7 @@ var app13 = new Hono13().get("/:name/variants", async (c) => {
   } catch {
   }
   const projectRoot = mindDir(mindName);
-  if (existsSync9(variant.path)) {
+  if (existsSync12(variant.path)) {
     const status = (await gitExec(["status", "--porcelain"], { cwd: variant.path })).trim();
     if (status) {
       try {
@@ -3972,7 +4509,7 @@ var app13 = new Hono13().get("/:name/variants", async (c) => {
         500
       );
     }
-    const verified = await verify(result.actualPort);
+    const verified = await verify2(result.actualPort);
     try {
       process.kill(result.child.pid);
     } catch {
@@ -4003,7 +4540,7 @@ var app13 = new Hono13().get("/:name/variants", async (c) => {
   } catch (e) {
     return c.json({ error: "Merge failed. Resolve conflicts manually." }, 500);
   }
-  if (existsSync9(variant.path)) {
+  if (existsSync12(variant.path)) {
     try {
       await gitExec(["worktree", "remove", "--force", variant.path], { cwd: projectRoot });
     } catch {
@@ -4020,7 +4557,7 @@ var app13 = new Hono13().get("/:name/variants", async (c) => {
       const [cmd, args] = wrapForIsolation("npm", ["install"], mindName);
       await exec(cmd, args, {
         cwd: projectRoot,
-        env: { ...process.env, HOME: resolve14(projectRoot, "home") }
+        env: { ...process.env, HOME: resolve17(projectRoot, "home") }
       });
     } else {
       await exec("npm", ["install"], { cwd: projectRoot });
@@ -4063,7 +4600,7 @@ var app13 = new Hono13().get("/:name/variants", async (c) => {
     } catch {
     }
   }
-  if (existsSync9(variant.path)) {
+  if (existsSync12(variant.path)) {
     try {
       await gitExec(["worktree", "remove", "--force", variant.path], { cwd: projectRoot });
     } catch {
@@ -4077,45 +4614,153 @@ var app13 = new Hono13().get("/:name/variants", async (c) => {
   chownMindDir(projectRoot, mindName);
   return c.json({ ok: true });
 });
-var variants_default = app13;
+var variants_default = app18;
 
-// src/web/api/volute/chat.ts
-import { readFileSync as readFileSync8 } from "fs";
-import { resolve as resolve15 } from "path";
-import { zValidator as zValidator4 } from "@hono/zod-validator";
-import { Hono as Hono14 } from "hono";
-import { streamSSE as streamSSE3 } from "hono/streaming";
-import { z as z4 } from "zod";
-var chatSchema = z4.object({
-  message: z4.string().optional(),
-  conversationId: z4.string().optional(),
-  sender: z4.string().optional(),
-  images: z4.array(
-    z4.object({
-      media_type: z4.string(),
-      data: z4.string()
-    })
-  ).optional()
+// src/web/api/volute/channels.ts
+import { zValidator as zValidator6 } from "@hono/zod-validator";
+import { Hono as Hono19 } from "hono";
+import { z as z6 } from "zod";
+var createSchema = z6.object({
+  name: z6.string().min(1).max(50).regex(/^[a-z0-9][a-z0-9-]*$/, "Channel names must be lowercase alphanumeric with hyphens")
+});
+var inviteSchema = z6.object({
+  username: z6.string().min(1)
 });
-function getDaemonUrl() {
+var app19 = new Hono19().get("/", async (c) => {
+  const user = c.get("user");
+  const channels = await listChannels();
+  const results = await Promise.all(
+    channels.map(async (ch) => {
+      const participants = await getParticipants(ch.id);
+      const isMember = participants.some((p) => p.userId === user.id);
+      return { ...ch, participantCount: participants.length, isMember };
+    })
+  );
+  return c.json(results);
+}).post("/", zValidator6("json", createSchema), async (c) => {
+  const user = c.get("user");
+  const body = c.req.valid("json");
   try {
-    const data = JSON.parse(readFileSync8(resolve15(voluteHome(), "daemon.json"), "utf-8"));
-    return `http://${daemonLoopback()}:${data.port}`;
+    const ch = await createChannel(body.name, user.id);
+    return c.json(ch, 201);
   } catch (err) {
-    throw new Error(`Failed to read daemon config: ${err instanceof Error ? err.message : err}`);
+    const cause = err instanceof Error ? err.cause : null;
+    if (cause && /UNIQUE/i.test(cause.extendedCode ?? cause.message ?? "")) {
+      return c.json({ error: "Channel already exists" }, 409);
+    }
+    throw err;
   }
-}
-function daemonFetchInternal(path, body) {
-  const daemonUrl = getDaemonUrl();
-  const token = process.env.VOLUTE_DAEMON_TOKEN;
-  const headers = {
-    "Content-Type": "application/json",
-    Origin: daemonUrl
+}).post("/:name/join", async (c) => {
+  const name = c.req.param("name");
+  const user = c.get("user");
+  const ch = await getChannelByName(name);
+  if (!ch) return c.json({ error: "Channel not found" }, 404);
+  await joinChannel(ch.id, user.id);
+  return c.json({ ok: true, conversationId: ch.id });
+}).post("/:name/leave", async (c) => {
+  const name = c.req.param("name");
+  const user = c.get("user");
+  const ch = await getChannelByName(name);
+  if (!ch) return c.json({ error: "Channel not found" }, 404);
+  await leaveChannel(ch.id, user.id);
+  return c.json({ ok: true });
+}).get("/:name/members", async (c) => {
+  const name = c.req.param("name");
+  const ch = await getChannelByName(name);
+  if (!ch) return c.json({ error: "Channel not found" }, 404);
+  const participants = await getParticipants(ch.id);
+  return c.json(participants);
+}).post("/:name/invite", zValidator6("json", inviteSchema), async (c) => {
+  const name = c.req.param("name");
+  const inviter = c.get("user");
+  const { username } = c.req.valid("json");
+  const ch = await getChannelByName(name);
+  if (!ch) return c.json({ error: "Channel not found" }, 404);
+  let user = await getUserByUsername(username);
+  if (!user && findMind(username)) {
+    user = await getOrCreateMindUser(username);
+  }
+  if (!user) return c.json({ error: "User not found" }, 404);
+  if (await isParticipant(ch.id, user.id)) {
+    return c.json({ error: "Already a member" }, 409);
+  }
+  await joinChannel(ch.id, user.id);
+  await addMessage(ch.id, "system", "system", [
+    { type: "text", text: `${inviter.username} invited ${username} to #${name}` }
+  ]);
+  return c.json({ ok: true });
+});
+var channels_default2 = app19;
+
+// src/web/api/volute/chat.ts
+import { zValidator as zValidator7 } from "@hono/zod-validator";
+import { Hono as Hono20 } from "hono";
+import { streamSSE as streamSSE3 } from "hono/streaming";
+import { z as z7 } from "zod";
+async function fanOutToMinds(opts) {
+  const participants = await getParticipants(opts.conversationId);
+  const mindParticipants = participants.filter((p) => p.userType === "mind");
+  const participantNames = participants.map((p) => p.username);
+  const isDM = opts.isDM ?? participants.length === 2;
+  const channelEntryType = opts.channelEntryType ?? (isDM ? "dm" : "group");
+  const { getMindManager: getMindManager2 } = await import("./mind-manager-RVCFROAY.js");
+  const manager = getMindManager2();
+  const runningMinds = mindParticipants.map((ap) => {
+    const key = opts.targetName ? opts.targetName(ap.username) : ap.username;
+    return manager.isRunning(key) ? ap.username : null;
+  }).filter((n) => n !== null && n !== opts.senderName);
+  function slugForMind(mindUsername) {
+    return buildVoluteSlug({
+      participants,
+      mindUsername,
+      convTitle: opts.convTitle,
+      conversationId: opts.conversationId,
+      ...opts.slugExtra
+    });
+  }
+  const channelEntry = {
+    platformId: opts.conversationId,
+    platform: "volute",
+    name: opts.convTitle ?? void 0,
+    type: channelEntryType
   };
-  if (token) headers.Authorization = `Bearer ${token}`;
-  return fetch(`${daemonUrl}${path}`, { method: "POST", headers, body });
+  for (const ap of mindParticipants) {
+    try {
+      writeChannelEntry(ap.username, slugForMind(ap.username), channelEntry);
+    } catch (err) {
+      logger_default.warn(`failed to write channel entry for ${ap.username}`, logger_default.errorData(err));
+    }
+  }
+  for (const mindName of runningMinds) {
+    const target = opts.targetName ? opts.targetName(mindName) : mindName;
+    const channel = slugForMind(mindName);
+    const typingMap = getTypingMap();
+    const currentlyTyping = typingMap.get(channel);
+    deliverMessage(target, {
+      content: opts.contentBlocks,
+      channel,
+      conversationId: opts.conversationId,
+      sender: opts.senderName,
+      participants: participantNames,
+      participantCount: participants.length,
+      isDM,
+      ...currentlyTyping.length > 0 ? { typing: currentlyTyping } : {}
+    }).catch(() => {
+    });
+  }
 }
-var app14 = new Hono14().post("/:name/chat", zValidator4("json", chatSchema), async (c) => {
+var chatSchema = z7.object({
+  message: z7.string().optional(),
+  conversationId: z7.string().optional(),
+  sender: z7.string().optional(),
+  images: z7.array(
+    z7.object({
+      media_type: z7.string(),
+      data: z7.string()
+    })
+  ).optional()
+});
+var app20 = new Hono20().post("/:name/chat", zValidator7("json", chatSchema), async (c) => {
   const name = c.req.param("name");
   const [baseName] = name.split("@", 2);
   const entry = findMind(baseName);
@@ -4151,8 +4796,8 @@ var app14 = new Hono14().post("/:name/chat", zValidator4("json", chatSchema), as
       }
     }
     if (!conversationId) {
-      const participantNames2 = /* @__PURE__ */ new Set([senderName, baseName]);
-      const title = [...participantNames2].join(", ");
+      const participantNames = /* @__PURE__ */ new Set([senderName, baseName]);
+      const title = [...participantNames].join(", ");
       const conv2 = await createConversation(baseName, "volute", {
         userId: user.id !== 0 ? user.id : void 0,
         title,
@@ -4162,7 +4807,7 @@ var app14 = new Hono14().post("/:name/chat", zValidator4("json", chatSchema), as
     }
   }
   const conv = await getConversation(conversationId);
-  const convTitle = conv?.title;
+  const convTitle = conv?.title ?? null;
   const contentBlocks = [];
   if (body.message) {
     contentBlocks.push({ type: "text", text: body.message });
@@ -4173,61 +4818,13 @@ var app14 = new Hono14().post("/:name/chat", zValidator4("json", chatSchema), as
     }
   }
   await addMessage(conversationId, "user", senderName, contentBlocks);
-  const participants = await getParticipants(conversationId);
-  const mindParticipants = participants.filter((p) => p.userType === "mind");
-  const participantNames = participants.map((p) => p.username);
-  const { getMindManager: getMindManager2 } = await import("./mind-manager-ETNCPQJN.js");
-  const manager = getMindManager2();
-  const runningMinds = mindParticipants.map((ap) => {
-    const mindKey = ap.username === baseName ? name : ap.username;
-    return manager.isRunning(mindKey) ? ap.username : null;
-  }).filter((n) => n !== null && n !== senderName);
-  const isDM = participants.length === 2;
-  function channelForMind(mindUsername) {
-    return buildVoluteSlug({
-      participants,
-      mindUsername,
-      convTitle,
-      conversationId
-    });
-  }
-  const channelEntry = {
-    platformId: conversationId,
-    platform: "volute",
-    name: convTitle ?? void 0,
-    type: isDM ? "dm" : "group"
-  };
-  for (const ap of mindParticipants) {
-    try {
-      writeChannelEntry(ap.username, channelForMind(ap.username), channelEntry);
-    } catch (err) {
-      console.warn(`[chat] failed to write channel entry for ${ap.username}:`, err);
-    }
-  }
-  for (const mindName of runningMinds) {
-    const targetName = mindName === baseName ? name : mindName;
-    const channel = channelForMind(mindName);
-    const typingMap = getTypingMap();
-    const currentlyTyping = typingMap.get(channel);
-    const payload = JSON.stringify({
-      content: contentBlocks,
-      channel,
-      conversationId,
-      sender: senderName,
-      participants: participantNames,
-      participantCount: participants.length,
-      isDM,
-      ...currentlyTyping.length > 0 ? { typing: currentlyTyping } : {}
-    });
-    daemonFetchInternal(`/api/minds/${encodeURIComponent(targetName)}/message`, payload).then(async (res) => {
-      if (!res.ok) {
-        const text2 = await res.text().catch(() => "");
-        console.error(`[chat] mind ${mindName} responded ${res.status}: ${text2}`);
-      }
-    }).catch((err) => {
-      console.error(`[chat] mind ${mindName} unreachable via daemon:`, err);
-    });
-  }
+  await fanOutToMinds({
+    conversationId,
+    contentBlocks,
+    senderName,
+    convTitle,
+    targetName: (username) => username === baseName ? name : username
+  });
   return c.json({ ok: true, conversationId });
 }).get("/:name/conversations/:id/events", async (c) => {
   const conversationId = c.req.param("id");
@@ -4246,27 +4843,68 @@ var app14 = new Hono14().post("/:name/chat", zValidator4("json", chatSchema), as
         if (!stream.aborted) console.error("[chat] SSE ping error:", err);
       });
     }, 15e3);
-    await new Promise((resolve18) => {
+    await new Promise((resolve20) => {
       stream.onAbort(() => {
         unsubscribe();
         clearInterval(keepAlive);
-        resolve18();
+        resolve20();
       });
     });
   });
 });
-var chat_default = app14;
+var unifiedChatSchema = z7.object({
+  message: z7.string().optional(),
+  conversationId: z7.string(),
+  images: z7.array(z7.object({ media_type: z7.string(), data: z7.string() })).optional()
+});
+var unifiedChatApp = new Hono20().post(
+  "/chat",
+  zValidator7("json", unifiedChatSchema),
+  async (c) => {
+    const user = c.get("user");
+    const body = c.req.valid("json");
+    if (!body.message && (!body.images || body.images.length === 0)) {
+      return c.json({ error: "message or images required" }, 400);
+    }
+    const conv = await getConversation(body.conversationId);
+    if (!conv) return c.json({ error: "Conversation not found" }, 404);
+    if (user.id !== 0 && !await isParticipantOrOwner(body.conversationId, user.id)) {
+      return c.json({ error: "Conversation not found" }, 404);
+    }
+    const senderName = user.username;
+    const contentBlocks = [];
+    if (body.message) contentBlocks.push({ type: "text", text: body.message });
+    if (body.images) {
+      for (const img of body.images) {
+        contentBlocks.push({ type: "image", media_type: img.media_type, data: img.data });
+      }
+    }
+    await addMessage(body.conversationId, "user", senderName, contentBlocks);
+    const isDM = conv.type === "dm";
+    await fanOutToMinds({
+      conversationId: body.conversationId,
+      contentBlocks,
+      senderName,
+      convTitle: conv.title,
+      isDM,
+      channelEntryType: conv.type === "channel" ? "group" : isDM ? "dm" : "group",
+      slugExtra: { convType: conv.type, convName: conv.name }
+    });
+    return c.json({ ok: true, conversationId: body.conversationId });
+  }
+);
+var chat_default = app20;
 
 // src/web/api/volute/conversations.ts
-import { zValidator as zValidator5 } from "@hono/zod-validator";
-import { Hono as Hono15 } from "hono";
-import { z as z5 } from "zod";
-var createConvSchema = z5.object({
-  title: z5.string().optional(),
-  participantIds: z5.array(z5.number()).optional(),
-  participantNames: z5.array(z5.string()).optional()
+import { zValidator as zValidator8 } from "@hono/zod-validator";
+import { Hono as Hono21 } from "hono";
+import { z as z8 } from "zod";
+var createConvSchema = z8.object({
+  title: z8.string().optional(),
+  participantIds: z8.array(z8.number()).optional(),
+  participantNames: z8.array(z8.string()).optional()
 });
-var app15 = new Hono15().get("/:name/conversations", async (c) => {
+var app21 = new Hono21().get("/:name/conversations", async (c) => {
   const name = c.req.param("name");
   const user = c.get("user");
   let lookupId = user.id;
@@ -4275,9 +4913,9 @@ var app15 = new Hono15().get("/:name/conversations", async (c) => {
     lookupId = mindUser.id;
   }
   const all = await listConversationsForUser(lookupId);
-  const convs = all.filter((c2) => c2.mind_name === name);
+  const convs = all.filter((c2) => c2.mind_name === name || c2.type === "channel");
   return c.json(convs);
-}).post("/:name/conversations", zValidator5("json", createConvSchema), async (c) => {
+}).post("/:name/conversations", zValidator8("json", createConvSchema), async (c) => {
   const name = c.req.param("name");
   const user = c.get("user");
   const body = c.req.valid("json");
@@ -4351,17 +4989,18 @@ var app15 = new Hono15().get("/:name/conversations", async (c) => {
   if (!deleted) return c.json({ error: "Conversation not found" }, 404);
   return c.json({ ok: true });
 });
-var conversations_default = app15;
+var conversations_default = app21;
 
 // src/web/api/volute/user-conversations.ts
-import { zValidator as zValidator6 } from "@hono/zod-validator";
-import { Hono as Hono16 } from "hono";
-import { z as z6 } from "zod";
-var createSchema = z6.object({
-  title: z6.string().optional(),
-  participantNames: z6.array(z6.string()).min(1)
+import { zValidator as zValidator9 } from "@hono/zod-validator";
+import { Hono as Hono22 } from "hono";
+import { streamSSE as streamSSE4 } from "hono/streaming";
+import { z as z9 } from "zod";
+var createSchema2 = z9.object({
+  title: z9.string().optional(),
+  participantNames: z9.array(z9.string()).min(1)
 });
-var app16 = new Hono16().use("*", authMiddleware).get("/", async (c) => {
+var app22 = new Hono22().use("*", authMiddleware).get("/", async (c) => {
   const user = c.get("user");
   const convs = await listConversationsWithParticipants(user.id);
   return c.json(convs);
@@ -4373,7 +5012,7 @@ var app16 = new Hono16().use("*", authMiddleware).get("/", async (c) => {
   }
   const msgs = await getMessages(id);
   return c.json(msgs);
-}).post("/", zValidator6("json", createSchema), async (c) => {
+}).post("/", zValidator9("json", createSchema2), async (c) => {
   const user = c.get("user");
   const body = c.req.valid("json");
   const participantIds = /* @__PURE__ */ new Set();
@@ -4403,6 +5042,31 @@ var app16 = new Hono16().use("*", authMiddleware).get("/", async (c) => {
     participantIds: [...participantIds]
   });
   return c.json(conv, 201);
+}).get("/:id/events", async (c) => {
+  const conversationId = c.req.param("id");
+  const user = c.get("user");
+  if (user.id !== 0 && !await isParticipantOrOwner(conversationId, user.id)) {
+    return c.json({ error: "Conversation not found" }, 404);
+  }
+  return streamSSE4(c, async (stream) => {
+    const unsubscribe = subscribe(conversationId, (event) => {
+      stream.writeSSE({ data: JSON.stringify(event) }).catch((err) => {
+        if (!stream.aborted) console.error("[chat] SSE write error:", err);
+      });
+    });
+    const keepAlive = setInterval(() => {
+      stream.writeSSE({ data: "" }).catch((err) => {
+        if (!stream.aborted) console.error("[chat] SSE ping error:", err);
+      });
+    }, 15e3);
+    await new Promise((resolve20) => {
+      stream.onAbort(() => {
+        unsubscribe();
+        clearInterval(keepAlive);
+        resolve20();
+      });
+    });
+  });
 }).delete("/:id", async (c) => {
   const id = c.req.param("id");
   const user = c.get("user");
@@ -4410,12 +5074,12 @@ var app16 = new Hono16().use("*", authMiddleware).get("/", async (c) => {
   if (!deleted) return c.json({ error: "Conversation not found" }, 404);
   return c.json({ ok: true });
 });
-var user_conversations_default = app16;
+var user_conversations_default = app22;
 
 // src/web/app.ts
 var httpLog = logger_default.child("http");
-var app17 = new Hono17();
-app17.onError((err, c) => {
+var app23 = new Hono23();
+app23.onError((err, c) => {
   if (err instanceof HTTPException) {
     return err.getResponse();
   }
@@ -4426,10 +5090,10 @@ app17.onError((err, c) => {
   });
   return c.json({ error: "Internal server error" }, 500);
 });
-app17.notFound((c) => {
+app23.notFound((c) => {
   return c.json({ error: "Not found" }, 404);
 });
-app17.use("*", async (c, next) => {
+app23.use("*", async (c, next) => {
   const start = Date.now();
   await next();
   const duration = Date.now() - start;
@@ -4440,7 +5104,7 @@ app17.use("*", async (c, next) => {
     httpLog.debug("request", data);
   }
 });
-app17.get("/api/health", (c) => {
+app23.get("/api/health", (c) => {
   let version = "unknown";
   let cached = null;
   try {
@@ -4455,15 +5119,18 @@ app17.get("/api/health", (c) => {
     ...cached?.updateAvailable ? { updateAvailable: true, latest: cached.latest } : {}
   });
 });
-app17.use("/api/*", bodyLimit({ maxSize: 10 * 1024 * 1024 }));
-app17.use("/api/*", csrf());
-app17.use("/api/minds/*", authMiddleware);
-app17.use("/api/conversations/*", authMiddleware);
-app17.use("/api/system/*", authMiddleware);
-app17.use("/api/env/*", authMiddleware);
-app17.route("/pages", pages_default);
-var routes = app17.route("/api/auth", auth_default).route("/api/system", system_default).route("/api/system", update_default).route("/api/minds", minds_default).route("/api/minds", chat_default).route("/api/minds", connectors_default).route("/api/minds", schedules_default).route("/api/minds", logs_default).route("/api/minds", typing_default).route("/api/minds", variants_default).route("/api/minds", files_default).route("/api/minds", channels_default).route("/api/minds", env_default).route("/api/minds", conversations_default).route("/api/env", sharedEnvApp).route("/api/conversations", user_conversations_default);
-var app_default = app17;
+app23.use("/api/*", bodyLimit({ maxSize: 10 * 1024 * 1024 }));
+app23.use("/api/*", csrf());
+app23.use("/api/minds/*", authMiddleware);
+app23.use("/api/conversations/*", authMiddleware);
+app23.use("/api/volute/*", authMiddleware);
+app23.use("/api/system/*", authMiddleware);
+app23.use("/api/env/*", authMiddleware);
+app23.use("/api/prompts/*", authMiddleware);
+app23.use("/api/skills/*", authMiddleware);
+app23.route("/pages", pages_default);
+var routes = app23.route("/api/keys", keys_default).route("/api/auth", auth_default).route("/api/system", system_default).route("/api/system", update_default).route("/api/minds", minds_default).route("/api/minds", chat_default).route("/api/minds", connectors_default).route("/api/minds", schedules_default).route("/api/minds", logs_default).route("/api/minds", typing_default).route("/api/minds", variants_default).route("/api/minds", files_default).route("/api/minds", channels_default).route("/api/minds", shared_default).route("/api/minds", env_default).route("/api/minds", mind_skills_default).route("/api/minds", conversations_default).route("/api/env", sharedEnvApp).route("/api/prompts", prompts_default).route("/api/skills", skills_default).route("/api/conversations", user_conversations_default).route("/api/volute/channels", channels_default2).route("/api/volute", unifiedChatApp);
+var app_default = app23;
 
 // src/web/server.ts
 var MIME_TYPES2 = {
@@ -4482,8 +5149,8 @@ async function startServer({
   let assetsDir = "";
   let searchDir = dirname3(new URL(import.meta.url).pathname);
   for (let i = 0; i < 5; i++) {
-    const candidate = resolve16(searchDir, "dist", "web-assets");
-    if (existsSync10(candidate)) {
+    const candidate = resolve18(searchDir, "dist", "web-assets");
+    if (existsSync13(candidate)) {
       assetsDir = candidate;
       break;
     }
@@ -4493,7 +5160,7 @@ async function startServer({
     app_default.get("*", async (c) => {
       const urlPath = new URL(c.req.url).pathname;
       if (urlPath.startsWith("/api/")) return c.notFound();
-      const filePath = resolve16(assetsDir, urlPath.slice(1));
+      const filePath = resolve18(assetsDir, urlPath.slice(1));
       if (!filePath.startsWith(assetsDir)) return c.text("Forbidden", 403);
       const s = await stat2(filePath).catch(() => null);
       if (s?.isFile()) {
@@ -4502,7 +5169,7 @@ async function startServer({
         const body = await readFile3(filePath);
         return c.body(body, 200, { "Content-Type": mime });
       }
-      const indexPath = resolve16(assetsDir, "index.html");
+      const indexPath = resolve18(assetsDir, "index.html");
       const indexStat = await stat2(indexPath).catch(() => null);
       if (indexStat?.isFile()) {
         const body = await readFile3(indexPath, "utf-8");
@@ -4512,10 +5179,10 @@ async function startServer({
     });
   }
   const server = serve({ fetch: app_default.fetch, port, hostname });
-  await new Promise((resolve18, reject) => {
+  await new Promise((resolve20, reject) => {
     server.on("listening", () => {
       logger_default.info("Volute UI running", { hostname, port });
-      resolve18();
+      resolve20();
     });
     server.on("error", (err) => {
       reject(err);
@@ -4526,14 +5193,14 @@ async function startServer({
 
 // src/daemon.ts
 if (!process.env.VOLUTE_HOME) {
-  process.env.VOLUTE_HOME = resolve17(homedir2(), ".volute");
+  process.env.VOLUTE_HOME = resolve19(homedir2(), ".volute");
 }
 async function startDaemon(opts) {
   const { port, hostname } = opts;
   const myPid = String(process.pid);
   const home = voluteHome();
   if (!opts.foreground) {
-    const rotatingLog = new RotatingLog(resolve17(home, "daemon.log"));
+    const rotatingLog = new RotatingLog(resolve19(home, "daemon.log"));
     logger_default.setOutput((line) => rotatingLog.write(`${line}
 `));
     const write = (...args) => rotatingLog.write(`${format(...args)}
@@ -4543,10 +5210,21 @@ async function startDaemon(opts) {
     console.warn = write;
     console.info = write;
   }
-  const DAEMON_PID_PATH = resolve17(home, "daemon.pid");
-  const DAEMON_JSON_PATH = resolve17(home, "daemon.json");
-  mkdirSync7(home, { recursive: true });
+  const DAEMON_PID_PATH = resolve19(home, "daemon.pid");
+  const DAEMON_JSON_PATH = resolve19(home, "daemon.json");
+  mkdirSync10(home, { recursive: true });
   migrateAgentsToMinds();
+  try {
+    await ensureSharedRepo();
+  } catch (err) {
+    logger_default.warn("failed to initialize shared repo", logger_default.errorData(err));
+  }
+  initRegistryCache();
+  try {
+    await syncBuiltinSkills();
+  } catch (err) {
+    logger_default.error("failed to sync built-in skills", logger_default.errorData(err));
+  }
   const token = process.env.VOLUTE_DAEMON_TOKEN || randomBytes(32).toString("hex");
   process.env.VOLUTE_DAEMON_TOKEN = token;
   process.env.VOLUTE_DAEMON_PORT = String(port);
@@ -4562,73 +5240,78 @@ async function startDaemon(opts) {
     }
     throw err;
   }
-  writeFileSync7(DAEMON_PID_PATH, myPid, { mode: 420 });
-  writeFileSync7(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
   });
+  const delivery = initDeliveryManager();
   const manager = initMindManager();
   manager.loadCrashAttempts();
   const connectors = initConnectorManager();
-  const scheduler = getScheduler();
-  scheduler.start(port, token);
-  const mailPoller = getMailPoller();
-  mailPoller.start(port, token);
-  const tokenBudget = getTokenBudget();
-  tokenBudget.start(port, token);
+  const scheduler = initScheduler();
+  scheduler.start();
+  const mailPoller = initMailPoller();
+  mailPoller.start();
+  const tokenBudget = initTokenBudget();
+  tokenBudget.start();
   const registry = readRegistry();
   for (const entry of registry) {
     try {
+      migrateDotVoluteDir(entry.name);
       migrateMindState(entry.name);
     } catch (err) {
       logger_default.warn(`failed to migrate state for ${entry.name}`, logger_default.errorData(err));
     }
   }
-  for (const entry of registry) {
-    if (!entry.running) continue;
-    try {
-      await manager.startMind(entry.name);
-      if (entry.stage === "seed") continue;
-      const dir = mindDir(entry.name);
-      await connectors.startConnectors(entry.name, dir, entry.port, port);
-      scheduler.loadSchedules(entry.name);
-      ensureMailAddress(entry.name).catch(() => {
-      });
-      const config = readVoluteConfig(dir);
-      if (config?.tokenBudget) {
-        tokenBudget.setBudget(
-          entry.name,
-          config.tokenBudget,
-          config.tokenBudgetPeriodMinutes ?? DEFAULT_BUDGET_PERIOD_MINUTES
-        );
+  const runningEntries = registry.filter((e) => e.running);
+  {
+    const queue = [...runningEntries];
+    const workers = Array.from({ length: Math.min(5, queue.length) }, async () => {
+      while (queue.length > 0) {
+        const entry = queue.shift();
+        try {
+          await startMindFull(entry.name);
+        } catch (err) {
+          logger_default.error(`failed to start mind ${entry.name}`, logger_default.errorData(err));
+          setMindRunning(entry.name, false);
+        }
       }
-    } catch (err) {
-      logger_default.error(`failed to start mind ${entry.name}`, logger_default.errorData(err));
-      setMindRunning(entry.name, false);
-    }
+    });
+    await Promise.all(workers);
   }
   const runningVariants = getAllRunningVariants();
-  for (const { mindName, variant } of runningVariants) {
-    const compositeKey = `${mindName}@${variant.name}`;
-    try {
-      await manager.startMind(compositeKey);
-    } catch (err) {
-      logger_default.error(`failed to start variant ${compositeKey}`, logger_default.errorData(err));
-      setVariantRunning(mindName, variant.name, false);
-    }
+  {
+    const queue = [...runningVariants];
+    const workers = Array.from({ length: Math.min(5, queue.length) }, async () => {
+      while (queue.length > 0) {
+        const { mindName, variant } = queue.shift();
+        const compositeKey = `${mindName}@${variant.name}`;
+        try {
+          await startMindFull(compositeKey);
+        } catch (err) {
+          logger_default.error(`failed to start variant ${compositeKey}`, logger_default.errorData(err));
+          setVariantRunning(mindName, variant.name, false);
+        }
+      }
+    });
+    await Promise.all(workers);
   }
+  delivery.restoreFromDb().catch((err) => {
+    logger_default.warn("failed to restore delivery queue", logger_default.errorData(err));
+  });
   cleanExpiredSessions().catch(() => {
   });
   logger_default.info(`running on ${hostname}:${port}, pid ${myPid}`);
   function cleanup() {
     try {
-      if (readFileSync9(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
+      if (readFileSync11(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
         unlinkSync2(DAEMON_PID_PATH);
       }
     } catch {
     }
     try {
-      const data = JSON.parse(readFileSync9(DAEMON_JSON_PATH, "utf-8"));
+      const data = JSON.parse(readFileSync11(DAEMON_JSON_PATH, "utf-8"));
       if (data.token === token) {
         unlinkSync2(DAEMON_JSON_PATH);
       }
@@ -4644,6 +5327,7 @@ async function startDaemon(opts) {
     scheduler.saveState();
     mailPoller.stop();
     tokenBudget.stop();
+    delivery.dispose();
     await connectors.stopAll();
     await manager.stopAll();
     manager.clearCrashAttempts();