volute 0.18.0 → 0.19.0

package/dist/daemon.js

@@ -1,39 +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,
-  conversationParticipants,
-  conversations,
-  getDb,
   getMindManager,
   getMindPromptDefaults,
   getPrompt,
   getPromptIfCustom,
   initMindManager,
   loadJsonMap,
-  logBuffer,
-  logger_default,
-  messages,
-  mindHistory,
   saveJsonMap,
-  sessions,
-  sharedSkills,
-  substitute,
-  systemPrompts,
-  users
-} from "./chunk-AYB7XAWO.js";
+  substitute
+} from "./chunk-2TJGRJ4O.js";
+import {
+  logBuffer,
+  logger_default
+} from "./chunk-YUIHSKR6.js";
+import {
+  CHANNELS,
+  getChannelDriver
+} from "./chunk-UJ6GHNR7.js";
 import {
   findOpenClawSession,
   importOpenClawConnectors,
@@ -41,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-FW5API7X.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,
@@ -65,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-GK4E7LM7.js";
+} from "./chunk-RHEGSQFJ.js";
 import {
   addMind,
   addVariant,
@@ -85,6 +116,7 @@ import {
   findMind,
   findVariant,
   getAllRunningVariants,
+  initRegistryCache,
   mindDir,
   nextPort,
   readRegistry,
@@ -99,14 +131,14 @@ import {
   validateBranchName,
   validateMindName,
   voluteHome
-} from "./chunk-M77QBTEH.js";
+} from "./chunk-EBGCNDMM.js";
 import "./chunk-K3NQKI34.js";
 
 // src/daemon.ts
 import { randomBytes } from "crypto";
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync10, unlinkSync as unlinkSync2, writeFileSync as writeFileSync8 } 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 resolve18 } from "path";
+import { resolve as resolve19 } from "path";
 import { format } from "util";
 
 // src/lib/connector-manager.ts
@@ -197,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 ?? [];
@@ -319,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) {
@@ -329,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;
@@ -356,23 +382,23 @@ var ConnectorManager = class {
     const stopKey = `${mindName}:${type}`;
     this.stopping.add(stopKey);
     mindMap.delete(type);
-    await new Promise((resolve19) => {
-      tracked.child.on("exit", () => resolve19());
+    await new Promise((resolve20) => {
+      tracked.child.on("exit", () => resolve20());
       try {
         tracked.child.kill("SIGTERM");
       } catch {
-        resolve19();
+        resolve20();
       }
       setTimeout(() => {
         try {
           tracked.child.kill("SIGKILL");
         } catch {
         }
-        resolve19();
+        resolve20();
       }, 5e3);
     });
     this.stopping.delete(stopKey);
-    this.restartAttempts.delete(stopKey);
+    this.restartTracker.reset(stopKey);
     try {
       this.removeConnectorPid(mindName, type);
     } catch (err) {
@@ -444,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;
 }
 
@@ -468,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;
@@ -486,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();
   }
@@ -643,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 text = formatEmailContent(email);
-    const body = JSON.stringify({
-      content: [{ type: "text", text }],
-      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);
     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) {
@@ -846,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 });
@@ -883,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);
   }
@@ -921,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) {
@@ -954,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() {
@@ -1030,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) {
@@ -1047,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) {
@@ -1097,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) => {
@@ -1106,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";
@@ -1180,7 +1212,7 @@ import { and, count, eq } from "drizzle-orm";
 async function createUser(username, password) {
   const db = await getDb();
   const hash = hashSync(password, 10);
-  const [{ value }] = await db.select({ value: count() }).from(users).where(eq(users.user_type, "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 db.insert(users).values({ username, password_hash: hash, role }).returning({
     id: users.id,
@@ -1315,6 +1347,8 @@ 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 db = await getDb();
   const sessionId = crypto.randomUUID();
@@ -1322,6 +1356,7 @@ async function createSession(userId) {
   return sessionId;
 }
 async function deleteSession(sessionId) {
+  sessionCache.delete(sessionId);
   const db = await getDb();
   await db.delete(sessions).where(eq2(sessions.id, sessionId));
 }
@@ -1352,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 existsSync11 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { readFile as readFile3, stat as stat2 } from "fs/promises";
-import { dirname as dirname2, extname as extname2, resolve as resolve17 } 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 Hono21 } 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";
@@ -1408,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());
@@ -1713,9 +1762,9 @@ var sharedEnvApp = new Hono4().get("/", (c) => {
 var env_default = app4;
 
 // src/web/api/files.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { readdir, readFile } from "fs/promises";
-import { resolve as resolve6 } from "path";
+import { resolve as resolve7 } from "path";
 import { Hono as Hono5 } from "hono";
 var ALLOWED_FILES = /* @__PURE__ */ new Set(["SOUL.md", "MEMORY.md", "CLAUDE.md", "VOLUTE.md"]);
 var app5 = new Hono5().get("/:name/files", async (c) => {
@@ -1723,8 +1772,8 @@ var app5 = new Hono5().get("/:name/files", async (c) => {
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const dir = mindDir(name);
-  const homeDir = resolve6(dir, "home");
-  if (!existsSync5(homeDir)) return c.json({ error: "Home directory missing" }, 404);
+  const homeDir = resolve7(dir, "home");
+  if (!existsSync6(homeDir)) return c.json({ error: "Home directory missing" }, 404);
   const allFiles = await readdir(homeDir);
   const files = allFiles.filter((f) => f.endsWith(".md") && ALLOWED_FILES.has(f));
   return c.json(files);
@@ -1737,8 +1786,8 @@ var app5 = new Hono5().get("/:name/files", async (c) => {
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const dir = mindDir(name);
-  const filePath = resolve6(dir, "home", filename);
-  if (!existsSync5(filePath)) {
+  const filePath = resolve7(dir, "home", filename);
+  if (!existsSync6(filePath)) {
     return c.json({ error: "File not found" }, 404);
   }
   const content = await readFile(filePath, "utf-8");
@@ -1746,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 existsSync6 } from "fs";
-import { resolve as resolve7 } 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 = resolve7(stateDir(name), "logs", "mind.log");
-  if (!existsSync6(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) => {
@@ -1775,17 +1915,17 @@ var app6 = new Hono6().get("/:name/logs", async (c) => {
     stream.onAbort(() => {
       tail.kill();
     });
-    await new Promise((resolve19) => {
-      tail.on("exit", resolve19);
-      stream.onAbort(resolve19);
+    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 = resolve7(stateDir(name), "logs", "mind.log");
-  if (!existsSync6(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);
@@ -1795,314 +1935,18 @@ var app6 = new Hono6().get("/:name/logs", async (c) => {
   tail.stdout.on("data", (data) => {
     output += data.toString();
   });
-  await new Promise((resolve19) => {
-    tail.on("exit", resolve19);
+  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 Hono7 } from "hono";
+import { Hono as Hono8 } from "hono";
 import { z as z2 } from "zod";
-
-// src/lib/skills.ts
-import {
-  cpSync,
-  existsSync as existsSync7,
-  mkdirSync as mkdirSync3,
-  readdirSync as readdirSync2,
-  readFileSync as readFileSync4,
-  rmSync,
-  writeFileSync as writeFileSync3
-} from "fs";
-import { tmpdir } from "os";
-import { basename, join, resolve as resolve8 } from "path";
-import { eq as eq3, sql } from "drizzle-orm";
-var VALID_SKILL_ID = /^[a-zA-Z0-9_-]+$/;
-function validateSkillId(id) {
-  if (!id || !VALID_SKILL_ID.test(id)) {
-    throw new Error(`Invalid skill ID: ${id}`);
-  }
-}
-function sharedSkillsDir() {
-  return resolve8(voluteHome(), "skills");
-}
-function parseSkillMd(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---/);
-  if (!match) return { name: "", description: "" };
-  const frontmatter = match[1];
-  const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
-  const descMatch = frontmatter.match(/^description:\s*(.+)$/m);
-  return {
-    name: nameMatch?.[1].trim() ?? "",
-    description: descMatch?.[1].trim() ?? ""
-  };
-}
-async function listSharedSkills() {
-  const db = await getDb();
-  return db.select().from(sharedSkills).all();
-}
-async function getSharedSkill(id) {
-  const db = await getDb();
-  return db.select().from(sharedSkills).where(eq3(sharedSkills.id, id)).get();
-}
-async function importSkillFromDir(sourceDir, author) {
-  const skillMdPath = join(sourceDir, "SKILL.md");
-  if (!existsSync7(skillMdPath)) {
-    throw new Error("SKILL.md not found in source directory");
-  }
-  const content = readFileSync4(skillMdPath, "utf-8");
-  const { name, description } = parseSkillMd(content);
-  const id = basename(sourceDir);
-  if (!id || id === "." || id === "..") {
-    throw new Error("Invalid skill directory name");
-  }
-  validateSkillId(id);
-  const destDir = join(sharedSkillsDir(), id);
-  if (existsSync7(destDir)) rmSync(destDir, { recursive: true });
-  mkdirSync3(destDir, { recursive: true });
-  cpSync(sourceDir, destDir, { recursive: true });
-  const upstreamPath = join(destDir, ".upstream.json");
-  if (existsSync7(upstreamPath)) rmSync(upstreamPath);
-  const db = await getDb();
-  const existing = await db.select().from(sharedSkills).where(eq3(sharedSkills.id, id)).get();
-  const version = existing ? existing.version + 1 : 1;
-  await db.insert(sharedSkills).values({ id, name: name || id, description, author, version }).onConflictDoUpdate({
-    target: sharedSkills.id,
-    set: {
-      name: name || id,
-      description,
-      author,
-      version,
-      updated_at: sql`(datetime('now'))`
-    }
-  });
-  const row = await db.select().from(sharedSkills).where(eq3(sharedSkills.id, id)).get();
-  if (!row) throw new Error(`Failed to upsert shared skill: ${id}`);
-  return row;
-}
-async function removeSharedSkill(id) {
-  const db = await getDb();
-  const existing = await db.select().from(sharedSkills).where(eq3(sharedSkills.id, id)).get();
-  if (!existing) throw new Error(`Shared skill not found: ${id}`);
-  await db.delete(sharedSkills).where(eq3(sharedSkills.id, id));
-  const dir = join(sharedSkillsDir(), id);
-  if (existsSync7(dir)) rmSync(dir, { recursive: true });
-}
-function mindSkillsDir(dir) {
-  return resolve8(dir, "home", ".claude", "skills");
-}
-function readUpstream(skillDir) {
-  const upstreamPath = join(skillDir, ".upstream.json");
-  if (!existsSync7(upstreamPath)) return null;
-  try {
-    const data = JSON.parse(readFileSync4(upstreamPath, "utf-8"));
-    if (typeof data?.source !== "string" || typeof data?.version !== "number" || typeof data?.baseCommit !== "string") {
-      return null;
-    }
-    return data;
-  } catch {
-    return null;
-  }
-}
-async function installSkill(_mindName, dir, skillId) {
-  validateSkillId(skillId);
-  const shared = await getSharedSkill(skillId);
-  if (!shared) throw new Error(`Shared skill not found: ${skillId}`);
-  const sourceDir = join(sharedSkillsDir(), skillId);
-  if (!existsSync7(sourceDir)) throw new Error(`Shared skill files not found: ${skillId}`);
-  const destDir = join(mindSkillsDir(dir), skillId);
-  if (existsSync7(destDir)) throw new Error(`Skill already installed: ${skillId}`);
-  mkdirSync3(destDir, { recursive: true });
-  cpSync(sourceDir, destDir, { recursive: true });
-  await gitExec(["add", join("home", ".claude", "skills", skillId)], { cwd: dir });
-  await gitExec(["commit", "-m", `Install shared skill: ${skillId}`], { cwd: dir });
-  const commitHash = (await gitExec(["rev-parse", "HEAD"], { cwd: dir })).trim();
-  const upstream = {
-    source: skillId,
-    version: shared.version,
-    baseCommit: commitHash
-  };
-  writeFileSync3(join(destDir, ".upstream.json"), `${JSON.stringify(upstream, null, 2)}
-`);
-  await gitExec(["add", join("home", ".claude", "skills", skillId, ".upstream.json")], {
-    cwd: dir
-  });
-  await gitExec(["commit", "--amend", "--no-edit"], { cwd: dir });
-}
-async function uninstallSkill(_mindName, dir, skillId) {
-  validateSkillId(skillId);
-  const skillDir = join(mindSkillsDir(dir), skillId);
-  if (!existsSync7(skillDir)) throw new Error(`Skill not installed: ${skillId}`);
-  rmSync(skillDir, { recursive: true });
-  await gitExec(["add", join("home", ".claude", "skills", skillId)], { cwd: dir });
-  await gitExec(["commit", "-m", `Uninstall skill: ${skillId}`], { cwd: dir });
-}
-async function updateSkill(_mindName, dir, skillId) {
-  validateSkillId(skillId);
-  const skillDir = join(mindSkillsDir(dir), skillId);
-  if (!existsSync7(skillDir)) throw new Error(`Skill not installed: ${skillId}`);
-  const upstream = readUpstream(skillDir);
-  if (!upstream) throw new Error(`No upstream tracking for skill: ${skillId}`);
-  const shared = await getSharedSkill(upstream.source);
-  if (!shared) throw new Error(`Shared skill no longer exists: ${upstream.source}`);
-  if (shared.version <= upstream.version) {
-    return { status: "up-to-date" };
-  }
-  const sourceDir = join(sharedSkillsDir(), upstream.source);
-  if (!existsSync7(sourceDir)) throw new Error(`Shared skill files missing: ${upstream.source}`);
-  const relSkillPath = join("home", ".claude", "skills", skillId);
-  const currentFiles = listFilesRecursive(skillDir).filter((f) => f !== ".upstream.json");
-  const newFiles = listFilesRecursive(sourceDir).filter((f) => f !== ".upstream.json");
-  const allFiles = [.../* @__PURE__ */ new Set([...currentFiles, ...newFiles])];
-  const conflictFiles = [];
-  const tmpBase = join(tmpdir(), `volute-merge-${process.pid}-${Date.now()}`);
-  mkdirSync3(tmpBase, { recursive: true });
-  try {
-    for (const file of allFiles) {
-      const currentPath = join(skillDir, file);
-      const newPath = join(sourceDir, file);
-      const currentExists = existsSync7(currentPath);
-      const newExists = existsSync7(newPath);
-      if (!currentExists && newExists) {
-        const destPath = join(skillDir, file);
-        mkdirSync3(join(skillDir, ...file.split("/").slice(0, -1)), { recursive: true });
-        cpSync(newPath, destPath);
-        continue;
-      }
-      if (currentExists && !newExists) {
-        let baseContent2 = null;
-        try {
-          baseContent2 = await gitExec(
-            ["show", `${upstream.baseCommit}:${join(relSkillPath, file)}`],
-            { cwd: dir }
-          );
-        } catch {
-          continue;
-        }
-        const currentContent2 = readFileSync4(currentPath, "utf-8");
-        if (currentContent2 === baseContent2) {
-          rmSync(currentPath);
-        }
-        continue;
-      }
-      let baseContent;
-      try {
-        baseContent = await gitExec(
-          ["show", `${upstream.baseCommit}:${join(relSkillPath, file)}`],
-          { cwd: dir }
-        );
-      } catch {
-        baseContent = "";
-      }
-      const currentContent = readFileSync4(currentPath, "utf-8");
-      const newContent = readFileSync4(newPath, "utf-8");
-      if (currentContent === baseContent) {
-        writeFileSync3(currentPath, newContent);
-        continue;
-      }
-      if (newContent === baseContent) {
-        continue;
-      }
-      const baseTmp = join(tmpBase, `${file}.base`);
-      const currentTmp = join(tmpBase, `${file}.current`);
-      const newTmp = join(tmpBase, `${file}.new`);
-      mkdirSync3(join(tmpBase, ...file.split("/").slice(0, -1)), { recursive: true });
-      writeFileSync3(baseTmp, baseContent);
-      writeFileSync3(currentTmp, currentContent);
-      writeFileSync3(newTmp, newContent);
-      try {
-        await exec("git", ["merge-file", currentTmp, baseTmp, newTmp]);
-        writeFileSync3(currentPath, readFileSync4(currentTmp, "utf-8"));
-      } catch (e) {
-        const exitCode = e && typeof e === "object" && "code" in e ? e.code : null;
-        if (exitCode === 1) {
-          writeFileSync3(currentPath, readFileSync4(currentTmp, "utf-8"));
-          conflictFiles.push(file);
-        } else {
-          throw e;
-        }
-      }
-    }
-  } finally {
-    rmSync(tmpBase, { recursive: true, force: true });
-  }
-  if (conflictFiles.length > 0) {
-    return { status: "conflict", conflictFiles };
-  }
-  const upstreamInfo = {
-    source: upstream.source,
-    version: shared.version,
-    baseCommit: upstream.baseCommit
-    // will update after commit
-  };
-  writeFileSync3(join(skillDir, ".upstream.json"), `${JSON.stringify(upstreamInfo, null, 2)}
-`);
-  await gitExec(["add", relSkillPath], { cwd: dir });
-  await gitExec(["commit", "-m", `Update skill: ${skillId} (v${shared.version})`], { cwd: dir });
-  const commitHash = (await gitExec(["rev-parse", "HEAD"], { cwd: dir })).trim();
-  upstreamInfo.baseCommit = commitHash;
-  writeFileSync3(join(skillDir, ".upstream.json"), `${JSON.stringify(upstreamInfo, null, 2)}
-`);
-  await gitExec(["add", join(relSkillPath, ".upstream.json")], { cwd: dir });
-  await gitExec(["commit", "--amend", "--no-edit"], { cwd: dir });
-  return { status: "updated" };
-}
-async function listMindSkills(dir) {
-  const skillsDir = mindSkillsDir(dir);
-  if (!existsSync7(skillsDir)) return [];
-  const entries = readdirSync2(skillsDir, { withFileTypes: true }).filter((e) => e.isDirectory());
-  const sharedMap = /* @__PURE__ */ new Map();
-  for (const s of await listSharedSkills()) {
-    sharedMap.set(s.id, s);
-  }
-  const results = [];
-  for (const entry of entries) {
-    const skillDir = join(skillsDir, entry.name);
-    const skillMdPath = join(skillDir, "SKILL.md");
-    let name = entry.name;
-    let description = "";
-    if (existsSync7(skillMdPath)) {
-      const parsed = parseSkillMd(readFileSync4(skillMdPath, "utf-8"));
-      if (parsed.name) name = parsed.name;
-      description = parsed.description;
-    }
-    const upstream = readUpstream(skillDir);
-    let updateAvailable = false;
-    if (upstream) {
-      const shared = sharedMap.get(upstream.source);
-      if (shared && shared.version > upstream.version) {
-        updateAvailable = true;
-      }
-    }
-    results.push({ id: entry.name, name, description, upstream, updateAvailable });
-  }
-  return results;
-}
-async function publishSkill(mindName, dir, skillId) {
-  const skillDir = join(mindSkillsDir(dir), skillId);
-  if (!existsSync7(skillDir)) throw new Error(`Skill not found: ${skillId}`);
-  const skillMdPath = join(skillDir, "SKILL.md");
-  if (!existsSync7(skillMdPath)) throw new Error(`SKILL.md not found in ${skillId}`);
-  return importSkillFromDir(skillDir, mindName);
-}
-function listFilesRecursive(dir, prefix = "") {
-  const results = [];
-  for (const entry of readdirSync2(dir, { withFileTypes: true })) {
-    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-    if (entry.isDirectory()) {
-      results.push(...listFilesRecursive(join(dir, entry.name), rel));
-    } else {
-      results.push(rel);
-    }
-  }
-  return results;
-}
-
-// src/web/api/mind-skills.ts
-var app7 = new Hono7().get("/:name/skills", async (c) => {
+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);
@@ -2177,39 +2021,39 @@ var app7 = new Hono7().get("/:name/skills", async (c) => {
   }
   return c.json({ ok: true });
 });
-var mind_skills_default = app7;
+var mind_skills_default = app8;
 
 // src/web/api/minds.ts
 import {
   cpSync as cpSync2,
-  existsSync as existsSync8,
-  mkdirSync as mkdirSync5,
+  existsSync as existsSync10,
+  mkdirSync as mkdirSync7,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync9,
   rmSync as rmSync2,
-  statSync,
-  writeFileSync as writeFileSync6
+  statSync as statSync2,
+  writeFileSync as writeFileSync8
 } from "fs";
-import { join as join2, resolve as resolve11 } from "path";
+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 eq5, sql as sql3 } from "drizzle-orm";
-import { Hono as Hono8 } from "hono";
+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 readdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } 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 = readFileSync5(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 = readdirSync3(memoryDir).filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f)).sort();
+    const files = readdirSync2(memoryDir).filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f)).sort();
     for (const filename of files) {
       const date = filename.replace(".md", "");
-      const content2 = readFileSync5(resolve9(memoryDir, filename), "utf-8").trim();
+      const content2 = readFileSync6(resolve10(memoryDir, filename), "utf-8").trim();
       if (content2) {
         logs.push(`### ${date}
 
@@ -2259,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) {
-    writeFileSync4(memoryPath, `${content}
+    writeFileSync5(memoryPath, `${content}
 `);
     console.log("MEMORY.md created successfully.");
   } else {
@@ -2269,7 +2113,7 @@ ${content2}`);
 
 // src/lib/conversations.ts
 import { randomUUID } from "crypto";
-import { and as and2, desc, eq as eq4, 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();
@@ -2339,7 +2183,7 @@ async function createConversation(mindName, channel, opts) {
 }
 async function getConversation(id) {
   const db = await getDb();
-  const row = await db.select().from(conversations).where(eq4(conversations.id, id)).get();
+  const row = await db.select().from(conversations).where(eq3(conversations.id, id)).get();
   return row ?? null;
 }
 async function addParticipant(conversationId, userId, role = "member") {
@@ -2354,8 +2198,8 @@ async function removeParticipant(conversationId, userId) {
   const db = await getDb();
   await db.delete(conversationParticipants).where(
     and2(
-      eq4(conversationParticipants.conversation_id, conversationId),
-      eq4(conversationParticipants.user_id, userId)
+      eq3(conversationParticipants.conversation_id, conversationId),
+      eq3(conversationParticipants.user_id, userId)
     )
   );
 }
@@ -2366,22 +2210,22 @@ async function getParticipants(conversationId) {
     username: users.username,
     userType: users.user_type,
     role: conversationParticipants.role
-  }).from(conversationParticipants).innerJoin(users, eq4(conversationParticipants.user_id, users.id)).where(eq4(conversationParticipants.conversation_id, conversationId)).all();
+  }).from(conversationParticipants).innerJoin(users, eq3(conversationParticipants.user_id, users.id)).where(eq3(conversationParticipants.conversation_id, conversationId)).all();
   return rows;
 }
 async function isParticipant(conversationId, userId) {
   const db = await getDb();
   const row = await db.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(
     and2(
-      eq4(conversationParticipants.conversation_id, conversationId),
-      eq4(conversationParticipants.user_id, userId)
+      eq3(conversationParticipants.conversation_id, conversationId),
+      eq3(conversationParticipants.user_id, userId)
     )
   ).get();
   return row != null;
 }
 async function listConversationsForUser(userId) {
   const db = await getDb();
-  const participantRows = await db.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(eq4(conversationParticipants.user_id, userId)).all();
+  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 await db.select().from(conversations).where(inArray(conversations.id, convIds)).orderBy(desc(conversations.updated_at)).all();
@@ -2389,7 +2233,7 @@ async function listConversationsForUser(userId) {
 async function isParticipantOrOwner(conversationId, userId) {
   if (await isParticipant(conversationId, userId)) return true;
   const db = await getDb();
-  const row = await db.select().from(conversations).where(and2(eq4(conversations.id, conversationId), eq4(conversations.user_id, userId))).get();
+  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) {
@@ -2401,12 +2245,12 @@ async function addMessage(conversationId, role, senderName, content) {
   const db = await getDb();
   const serialized = JSON.stringify(content);
   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: sql2`datetime('now')` }).where(eq4(conversations.id, conversationId));
+  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 db.update(conversations).set({ title }).where(and2(eq4(conversations.id, conversationId), isNull(conversations.title)));
+      await db.update(conversations).set({ title }).where(and2(eq3(conversations.id, conversationId), isNull(conversations.title)));
     }
   }
   const msg = {
@@ -2429,7 +2273,7 @@ async function addMessage(conversationId, role, senderName, content) {
 }
 async function getMessages(conversationId) {
   const db = await getDb();
-  const rows = await db.select().from(messages).where(eq4(messages.conversation_id, conversationId)).orderBy(messages.created_at).all();
+  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 {
@@ -2452,7 +2296,7 @@ async function listConversationsWithParticipants(userId) {
     username: users.username,
     userType: users.user_type,
     role: conversationParticipants.role
-  }).from(conversationParticipants).innerJoin(users, eq4(conversationParticipants.user_id, users.id)).where(inArray(conversationParticipants.conversation_id, convIds));
+  }).from(conversationParticipants).innerJoin(users, eq3(conversationParticipants.user_id, users.id)).where(inArray(conversationParticipants.conversation_id, convIds));
   const byConv = /* @__PURE__ */ new Map();
   for (const r of rows) {
     let arr = byConv.get(r.conversationId);
@@ -2469,7 +2313,7 @@ async function listConversationsWithParticipants(userId) {
   }
   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) {
@@ -2505,9 +2349,9 @@ async function listConversationsWithParticipants(userId) {
 }
 async function findDMConversation(mindName, participantIds) {
   const db = await getDb();
-  const mindConvs = await db.select({ id: conversations.id }).from(conversations).where(and2(eq4(conversations.mind_name, mindName), eq4(conversations.type, "dm"))).all();
+  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 db.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(eq4(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])) {
@@ -2518,7 +2362,7 @@ async function findDMConversation(mindName, participantIds) {
 }
 async function deleteConversation(id) {
   const db = await getDb();
-  await db.delete(conversations).where(eq4(conversations.id, id));
+  await db.delete(conversations).where(eq3(conversations.id, id));
 }
 async function createChannel(name, creatorId) {
   const participantIds = creatorId ? [creatorId] : [];
@@ -2531,12 +2375,12 @@ async function createChannel(name, creatorId) {
 }
 async function getChannelByName(name) {
   const db = await getDb();
-  const row = await db.select().from(conversations).where(and2(eq4(conversations.name, name), eq4(conversations.type, "channel"))).get();
+  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(eq4(conversations.type, "channel")).orderBy(conversations.name).all();
+  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;
@@ -2548,11 +2392,11 @@ async function leaveChannel(conversationId, userId) {
 
 // src/lib/convert-session.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } 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 = readFileSync6(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 = [];
@@ -2666,10 +2510,10 @@ function convertSession(opts) {
     }
   }
   const projectId = opts.projectDir.replace(/\//g, "-");
-  const sdkDir = resolve10(homedir(), ".claude", "projects", projectId);
-  mkdirSync4(sdkDir, { recursive: true });
-  const sdkPath = resolve10(sdkDir, `${sessionId}.jsonl`);
-  writeFileSync5(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;
@@ -2748,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);
+  }
+  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);
+  }
+  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));
     }
   }
-  /** 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);
-      }
+  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));
     }
   }
-  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);
-      }
-    }
-    return result;
-  }
-  dispose() {
-    clearInterval(this.sweepTimer);
-    this.channels.clear();
-    if (instance5 === this) instance5 = void 0;
-  }
-  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(readFileSync7(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";
@@ -2905,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 });
@@ -2916,7 +2751,7 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
     await gitExec(["worktree", "remove", "--force", tempWorktree], { cwd: projectRoot });
   } catch {
   }
-  if (existsSync8(tempWorktree)) {
+  if (existsSync10(tempWorktree)) {
     rmSync2(tempWorktree, { recursive: true, force: true });
   }
   const templatesRoot = findTemplatesRoot();
@@ -2937,8 +2772,8 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
       });
     }
     copyTemplateToDir(composedDir, tempWorktree, mindName, manifest);
-    const initDir = resolve11(tempWorktree, ".init");
-    if (existsSync8(initDir)) {
+    const initDir = resolve13(tempWorktree, ".init");
+    if (existsSync10(initDir)) {
       rmSync2(initDir, { recursive: true, force: true });
     }
     await gitExec(["add", "-A"], { cwd: tempWorktree });
@@ -2952,7 +2787,7 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
       await gitExec(["worktree", "remove", "--force", tempWorktree], { cwd: projectRoot });
     } catch {
     }
-    if (existsSync8(tempWorktree)) {
+    if (existsSync10(tempWorktree)) {
       rmSync2(tempWorktree, { recursive: true, force: true });
     }
     rmSync2(composedDir, { recursive: true, force: true });
@@ -2978,20 +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 });
   }
 }
+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()
+  seedSoul: z3.string().optional(),
+  skills: z3.array(z3.string()).optional()
 });
-var app8 = new Hono8().post("/", requireAdmin, zValidator3("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);
@@ -2999,28 +2939,29 @@ var app8 = new Hono8().post("/", requireAdmin, zValidator3("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(readFileSync7(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;
-      writeFileSync6(configPath, `${JSON.stringify(existing, null, 2)}
+      writeFileSync8(configPath, `${JSON.stringify(existing, null, 2)}
 `);
     }
     const mindPrompts = await getMindPromptDefaults();
-    writeFileSync6(
-      resolve11(dest, "home/.config/prompts.json"),
+    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);
@@ -3031,10 +2972,15 @@ var app8 = new Hono8().post("/", requireAdmin, zValidator3("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);
-      rmSync2(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 ? `
@@ -3042,33 +2988,42 @@ The human who planted you described you as: "${body.description}"
 ` : "";
       const seedSoulRaw = body.seedSoul ?? await getPrompt("seed_soul", { name, description: descLine });
       const seedSoul = body.seedSoul ? substitute(seedSoulRaw, { name, description: descLine }) : seedSoulRaw;
-      writeFileSync6(resolve11(dest, "home/SOUL.md"), seedSoul);
-      const skillsDir = resolve11(dest, manifest.skillsDir);
-      for (const skill of ["volute-mind", "memory", "sessions"]) {
-        const skillPath = resolve11(skillsDir, skill);
-        if (existsSync8(skillPath)) rmSync2(skillPath, { recursive: true, force: true });
+      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) {
-        writeFileSync6(resolve11(dest, "home/SOUL.md"), customSoul.replace(/\{\{name\}\}/g, name));
+        writeFileSync8(resolve13(dest, "home/SOUL.md"), customSoul.replace(/\{\{name\}\}/g, name));
       }
       const customMemory = await getPromptIfCustom("default_memory");
       if (customMemory) {
-        writeFileSync6(resolve11(dest, "home/MEMORY.md"), 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)) rmSync2(dest, { recursive: true, force: true });
+    if (existsSync10(dest)) rmSync2(dest, { recursive: true, force: true });
     try {
       removeMind(name);
     } catch {
@@ -3084,14 +3039,17 @@ The human who planted you described you as: "${body.description}"
   } 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 = readFileSync7(resolve11(wsDir, "SOUL.md"), "utf-8");
-  const identity = readFileSync7(resolve11(wsDir, "IDENTITY.md"), "utf-8");
-  const userPath = resolve11(wsDir, "USER.md");
-  const user = existsSync8(userPath) ? readFileSync7(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);
@@ -3111,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);
-    writeFileSync6(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 = readFileSync7(wsMemoryPath, "utf-8");
-      writeFileSync6(
-        resolve11(dest, "home/MEMORY.md"),
+      const existingMemory = readFileSync9(wsMemoryPath, "utf-8");
+      writeFileSync8(
+        resolve13(dest, "home/MEMORY.md"),
         `${existingMemory.trimEnd()}${mergedMemoryExtra}`
       );
     } else if (user) {
-      writeFileSync6(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");
+    if (existsSync10(wsMemoryDir)) {
+      const destMemoryDir = resolve13(dest, "home/memory");
       const files = readdirSync4(wsMemoryDir).filter((f) => f.endsWith(".md"));
       for (const file of files) {
-        cpSync2(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);
@@ -3150,26 +3109,34 @@ ${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");
-        mkdirSync5(voluteDir, { recursive: true });
-        writeFileSync6(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)) rmSync2(dest, { recursive: true, force: true });
+    if (existsSync10(dest)) rmSync2(dest, { recursive: true, force: true });
     try {
       removeMind(name);
     } catch {
@@ -3185,7 +3152,7 @@ ${user.trimEnd()}
     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 {
@@ -3193,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,
@@ -3208,8 +3175,8 @@ ${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 = readdirSync4(pagesDir);
@@ -3218,9 +3185,9 @@ ${user.trimEnd()}
       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,
@@ -3229,9 +3196,9 @@ ${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: join2(item, "index.html"),
@@ -3255,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();
@@ -3270,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");
@@ -3282,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);
@@ -3303,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");
@@ -3312,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);
@@ -3330,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 {
@@ -3343,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)
               );
             }
           }
@@ -3358,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
@@ -3379,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));
         }
       }
     }
@@ -3389,17 +3352,17 @@ ${user.trimEnd()}
     if (context?.type === "sprouted" && !variantName) {
       try {
         const db = await getDb();
-        const activeConvs = await db.select({ id: conversations.id }).from(conversations).where(eq5(conversations.mind_name, baseName)).all();
+        const activeConvs = await db.select({ id: conversations.id }).from(conversations).where(eq4(conversations.mind_name, baseName)).all();
         for (const conv of activeConvs) {
           await addMessage(conv.id, "assistant", "system", [
             { type: "text", text: "[seed has sprouted]" }
           ]);
         }
       } 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);
@@ -3418,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);
@@ -3445,18 +3403,21 @@ ${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)) {
+  if (existsSync10(state)) {
     rmSync2(state, { recursive: true, force: true });
   }
-  if (force && existsSync8(dir)) {
+  if (force && existsSync10(dir)) {
     rmSync2(dir, { recursive: true, force: true });
     deleteMindUser(name);
   }
@@ -3466,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 });
@@ -3525,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(
@@ -3536,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
@@ -3548,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)) {
-    mkdirSync5(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);
@@ -3597,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(
@@ -3612,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);
@@ -3626,7 +3595,7 @@ ${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 db = await getDb();
@@ -3642,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();
@@ -3656,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 = `
@@ -3676,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 db.select({ count: sql3`count(*)` }).from(mindHistory).where(eq5(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.]";
@@ -3690,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 text = await res.text().catch(() => "");
-      console.error(`[daemon] mind ${name} responded with ${res.status}: ${text}`);
-    }
-  }).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) => {
@@ -3719,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);
@@ -3743,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,
@@ -3754,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;
@@ -3827,7 +3835,7 @@ ${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 });
@@ -3836,16 +3844,16 @@ ${user.trimEnd()}
   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(eq5(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 db = await getDb();
-  const rows = await db.selectDistinct({ channel: mindHistory.channel }).from(mindHistory).where(eq5(mindHistory.mind, name));
+  const rows = await db.selectDistinct({ channel: mindHistory.channel }).from(mindHistory).where(eq4(mindHistory.mind, name));
   return c.json(rows.map((r) => r.channel));
 }).get("/:name/history", async (c) => {
   const name = c.req.param("name");
@@ -3855,25 +3863,25 @@ ${user.trimEnd()}
   const limit = Math.min(Math.max(parseInt(c.req.query("limit") ?? "50", 10) || 50, 1), 200);
   const offset = Math.max(parseInt(c.req.query("offset") ?? "0", 10) || 0, 0);
   const db = await getDb();
-  const conditions = [eq5(mindHistory.mind, name)];
+  const conditions = [eq4(mindHistory.mind, name)];
   if (channel) {
-    conditions.push(eq5(mindHistory.channel, channel));
+    conditions.push(eq4(mindHistory.channel, channel));
   }
   if (session) {
-    conditions.push(eq5(mindHistory.session, session));
+    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 db.select().from(mindHistory).where(and3(...conditions)).orderBy(desc2(mindHistory.created_at)).limit(limit).offset(offset);
   return c.json(rows);
 });
-var minds_default = app8;
+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 Hono9 } from "hono";
+import { extname, resolve as resolve14 } from "path";
+import { Hono as Hono10 } from "hono";
 var MIME_TYPES = {
   ".html": "text/html",
   ".js": "application/javascript",
@@ -3890,16 +3898,16 @@ var MIME_TYPES = {
   ".txt": "text/plain",
   ".xml": "application/xml"
 };
-var app9 = new Hono9().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);
@@ -3915,14 +3923,14 @@ var app9 = new Hono9().get("/:name/*", async (c) => {
   }
   return c.text("Not found", 404);
 });
-var pages_default = app9;
+var pages_default = app10;
 
 // src/web/api/prompts.ts
 import { zValidator as zValidator4 } from "@hono/zod-validator";
-import { eq as eq6, sql as sql4 } from "drizzle-orm";
-import { Hono as Hono10 } from "hono";
+import { eq as eq5, sql as sql3 } from "drizzle-orm";
+import { Hono as Hono11 } from "hono";
 import { z as z4 } from "zod";
-var app10 = new Hono10().get("/", async (c) => {
+var app11 = new Hono11().get("/", async (c) => {
   let rows;
   try {
     const db = await getDb();
@@ -3952,9 +3960,9 @@ var app10 = new Hono10().get("/", async (c) => {
   }
   const { content } = c.req.valid("json");
   const db = await getDb();
-  await db.insert(systemPrompts).values({ key, content, updated_at: sql4`(datetime('now'))` }).onConflictDoUpdate({
+  await db.insert(systemPrompts).values({ key, content, updated_at: sql3`(datetime('now'))` }).onConflictDoUpdate({
     target: systemPrompts.key,
-    set: { content, updated_at: sql4`(datetime('now'))` }
+    set: { content, updated_at: sql3`(datetime('now'))` }
   });
   return c.json({ ok: true });
 }).delete("/:key", requireAdmin, async (c) => {
@@ -3963,13 +3971,13 @@ var app10 = new Hono10().get("/", async (c) => {
     return c.json({ error: "Unknown prompt key" }, 404);
   }
   const db = await getDb();
-  await db.delete(systemPrompts).where(eq6(systemPrompts.key, key));
+  await db.delete(systemPrompts).where(eq5(systemPrompts.key, key));
   return c.json({ ok: true });
 });
-var prompts_default = app10;
+var prompts_default = app11;
 
 // src/web/api/schedules.ts
-import { Hono as Hono11 } from "hono";
+import { Hono as Hono12 } from "hono";
 function readSchedules(name) {
   return readVoluteConfig(mindDir(name))?.schedules ?? [];
 }
@@ -3980,7 +3988,7 @@ function writeSchedules(name, schedules) {
   writeVoluteConfig(dir, config);
   getScheduler().loadSchedules(name);
 }
-var app11 = new Hono11().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));
@@ -4051,15 +4059,68 @@ var app11 = new Hono11().get("/:name/schedules", (c) => {
     return c.json({ error: "Failed to reach mind" }, 502);
   }
 });
-var schedules_default = app11;
+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 existsSync9, mkdtempSync, readdirSync as readdirSync5, rmSync as rmSync3 } from "fs";
+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 resolve13 } from "path";
+import { join as join3, resolve as resolve15 } from "path";
 import AdmZip from "adm-zip";
-import { Hono as Hono12 } from "hono";
-var app12 = new Hono12().get("/", async (c) => {
+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) => {
@@ -4083,19 +4144,19 @@ var app12 = new Hono12().get("/", async (c) => {
   try {
     const zip = new AdmZip(buffer);
     for (const entry of zip.getEntries()) {
-      const target = resolve13(tmpDir, entry.entryName);
+      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 (existsSync9(join3(tmpDir, "SKILL.md"))) {
+    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 (existsSync9(join3(tmpDir, entry.name, "SKILL.md"))) {
+        if (existsSync11(join3(tmpDir, entry.name, "SKILL.md"))) {
           skillDir = join3(tmpDir, entry.name);
           break;
         }
@@ -4124,12 +4185,12 @@ var app12 = new Hono12().get("/", async (c) => {
   }
   return c.json({ ok: true });
 });
-var skills_default = app12;
+var skills_default = app14;
 
 // src/web/api/system.ts
-import { Hono as Hono13 } from "hono";
+import { Hono as Hono15 } from "hono";
 import { streamSSE as streamSSE2 } from "hono/streaming";
-var app13 = new Hono13().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) => {
@@ -4146,10 +4207,10 @@ var app13 = new Hono13().post("/restart", requireAdmin, (c) => {
       stream.writeSSE({ data: JSON.stringify(entry) }).catch(() => {
       });
     });
-    await new Promise((resolve19) => {
+    await new Promise((resolve20) => {
       stream.onAbort(() => {
         unsubscribe();
-        resolve19();
+        resolve20();
       });
     });
   });
@@ -4157,18 +4218,18 @@ var app13 = new Hono13().post("/restart", requireAdmin, (c) => {
   const config = readSystemsConfig();
   return c.json({ system: config?.system ?? null });
 });
-var system_default = app13;
+var system_default = app15;
 
 // src/web/api/typing.ts
 import { zValidator as zValidator5 } from "@hono/zod-validator";
-import { Hono as Hono14 } from "hono";
+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 app14 = new Hono14().post("/:name/typing", zValidator5("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) {
@@ -4185,13 +4246,13 @@ var app14 = new Hono14().post("/:name/typing", zValidator5("json", typingSchema)
   const map = getTypingMap();
   return c.json({ typing: map.get(channel) });
 });
-var typing_default = app14;
+var typing_default = app16;
 
 // src/web/api/update.ts
 import { spawn as spawn3 } from "child_process";
-import { Hono as Hono15 } from "hono";
+import { Hono as Hono17 } from "hono";
 var bin;
-var app15 = new Hono15().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) => {
@@ -4206,19 +4267,19 @@ var app15 = new Hono15().get("/update", async (c) => {
   child.unref();
   return c.json({ ok: true, message: "Updating..." });
 });
-var update_default = app15;
+var update_default = app17;
 
 // src/web/api/variants.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "fs";
-import { resolve as resolve15 } from "path";
-import { Hono as Hono16 } 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 mkdirSync6, openSync, readFileSync as readFileSync8 } from "fs";
-import { resolve as resolve14 } from "path";
+import { closeSync, mkdirSync as mkdirSync8, openSync, readFileSync as readFileSync10 } from "fs";
+import { resolve as resolve16 } from "path";
 function tsxBin(cwd) {
-  return resolve14(cwd, "node_modules", ".bin", "tsx");
+  return resolve16(cwd, "node_modules", ".bin", "tsx");
 }
 function spawnServer(cwd, port, options) {
   if (options?.detached) {
@@ -4231,31 +4292,31 @@ function spawnAttached(cwd, port) {
     cwd,
     stdio: ["ignore", "pipe", "pipe"]
   });
-  return new Promise((resolve19) => {
-    const timeout = setTimeout(() => resolve19(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);
-        resolve19({ 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);
-      resolve19(null);
+      resolve20(null);
     });
     child.on("exit", () => {
       clearTimeout(timeout);
-      resolve19(null);
+      resolve20(null);
     });
   });
 }
 function spawnDetached(cwd, port, logDir) {
-  const logsDir = logDir ?? resolve14(cwd, ".volute", "logs");
-  mkdirSync6(logsDir, { recursive: true });
-  const logPath = resolve14(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,
@@ -4275,7 +4336,7 @@ function spawnDetached(cwd, port, logDir) {
     }
     const interval = setInterval(() => {
       try {
-        const content = readFileSync8(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) });
@@ -4290,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");
@@ -4327,7 +4388,7 @@ async function verify(port) {
 }
 
 // src/web/api/variants.ts
-var app16 = new Hono16().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);
@@ -4357,11 +4418,11 @@ var app16 = new Hono16().get("/:name/variants", async (c) => {
   const err = validateBranchName(variantName);
   if (err) return c.json({ error: err }, 400);
   const projectRoot = mindDir(mindName);
-  const variantDir = resolve15(projectRoot, ".variants", variantName);
-  if (existsSync10(variantDir)) {
+  const variantDir = resolve17(projectRoot, ".variants", variantName);
+  if (existsSync12(variantDir)) {
     return c.json({ error: `Variant directory already exists: ${variantDir}` }, 409);
   }
-  mkdirSync7(resolve15(projectRoot, ".variants"), { recursive: true });
+  mkdirSync9(resolve17(projectRoot, ".variants"), { recursive: true });
   try {
     await gitExec(["worktree", "add", "-b", variantName, variantDir], { cwd: projectRoot });
   } catch (e) {
@@ -4374,7 +4435,7 @@ var app16 = new Hono16().get("/:name/variants", async (c) => {
       const [cmd, args] = wrapForIsolation("npm", ["install"], mindName);
       await exec(cmd, args, {
         cwd: variantDir,
-        env: { ...process.env, HOME: resolve15(variantDir, "home") }
+        env: { ...process.env, HOME: resolve17(variantDir, "home") }
       });
     } else {
       await exec("npm", ["install"], { cwd: variantDir });
@@ -4384,7 +4445,7 @@ var app16 = new Hono16().get("/:name/variants", async (c) => {
     return c.json({ error: `npm install failed: ${msg}` }, 500);
   }
   if (body.soul) {
-    writeFileSync7(resolve15(variantDir, "home/SOUL.md"), body.soul);
+    writeFileSync9(resolve17(variantDir, "home/SOUL.md"), body.soul);
   }
   const variantPort = body.port ?? nextPort();
   const variant = {
@@ -4422,7 +4483,7 @@ var app16 = new Hono16().get("/:name/variants", async (c) => {
   } catch {
   }
   const projectRoot = mindDir(mindName);
-  if (existsSync10(variant.path)) {
+  if (existsSync12(variant.path)) {
     const status = (await gitExec(["status", "--porcelain"], { cwd: variant.path })).trim();
     if (status) {
       try {
@@ -4448,7 +4509,7 @@ var app16 = new Hono16().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 {
@@ -4479,7 +4540,7 @@ var app16 = new Hono16().get("/:name/variants", async (c) => {
   } catch (e) {
     return c.json({ error: "Merge failed. Resolve conflicts manually." }, 500);
   }
-  if (existsSync10(variant.path)) {
+  if (existsSync12(variant.path)) {
     try {
       await gitExec(["worktree", "remove", "--force", variant.path], { cwd: projectRoot });
     } catch {
@@ -4496,7 +4557,7 @@ var app16 = new Hono16().get("/:name/variants", async (c) => {
       const [cmd, args] = wrapForIsolation("npm", ["install"], mindName);
       await exec(cmd, args, {
         cwd: projectRoot,
-        env: { ...process.env, HOME: resolve15(projectRoot, "home") }
+        env: { ...process.env, HOME: resolve17(projectRoot, "home") }
       });
     } else {
       await exec("npm", ["install"], { cwd: projectRoot });
@@ -4539,7 +4600,7 @@ var app16 = new Hono16().get("/:name/variants", async (c) => {
     } catch {
     }
   }
-  if (existsSync10(variant.path)) {
+  if (existsSync12(variant.path)) {
     try {
       await gitExec(["worktree", "remove", "--force", variant.path], { cwd: projectRoot });
     } catch {
@@ -4553,16 +4614,19 @@ var app16 = new Hono16().get("/:name/variants", async (c) => {
   chownMindDir(projectRoot, mindName);
   return c.json({ ok: true });
 });
-var variants_default = app16;
+var variants_default = app18;
 
 // src/web/api/volute/channels.ts
 import { zValidator as zValidator6 } from "@hono/zod-validator";
-import { Hono as Hono17 } from "hono";
+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 app17 = new Hono17().get("/", async (c) => {
+var inviteSchema = z6.object({
+  username: z6.string().min(1)
+});
+var app19 = new Hono19().get("/", async (c) => {
   const user = c.get("user");
   const channels = await listChannels();
   const results = await Promise.all(
@@ -4606,16 +4670,85 @@ var app17 = new Hono17().get("/", async (c) => {
   if (!ch) return c.json({ error: "Channel not found" }, 404);
   const participants = await getParticipants(ch.id);
   return c.json(participants);
+}).post("/:name/invite", 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 = app17;
+var channels_default2 = app19;
 
 // src/web/api/volute/chat.ts
-import { readFileSync as readFileSync9 } from "fs";
-import { resolve as resolve16 } from "path";
 import { zValidator as zValidator7 } from "@hono/zod-validator";
-import { Hono as Hono18 } from "hono";
+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
+  };
+  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 chatSchema = z7.object({
   message: z7.string().optional(),
   conversationId: z7.string().optional(),
@@ -4627,25 +4760,7 @@ var chatSchema = z7.object({
     })
   ).optional()
 });
-function getDaemonUrl() {
-  try {
-    const data = JSON.parse(readFileSync9(resolve16(voluteHome(), "daemon.json"), "utf-8"));
-    return `http://${daemonLoopback()}:${data.port}`;
-  } catch (err) {
-    throw new Error(`Failed to read daemon config: ${err instanceof Error ? err.message : err}`);
-  }
-}
-function daemonFetchInternal(path, body) {
-  const daemonUrl = getDaemonUrl();
-  const token = process.env.VOLUTE_DAEMON_TOKEN;
-  const headers = {
-    "Content-Type": "application/json",
-    Origin: daemonUrl
-  };
-  if (token) headers.Authorization = `Bearer ${token}`;
-  return fetch(`${daemonUrl}${path}`, { method: "POST", headers, body });
-}
-var app18 = new Hono18().post("/:name/chat", zValidator7("json", chatSchema), async (c) => {
+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);
@@ -4681,8 +4796,8 @@ var app18 = new Hono18().post("/:name/chat", zValidator7("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,
@@ -4692,7 +4807,7 @@ var app18 = new Hono18().post("/:name/chat", zValidator7("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 });
@@ -4703,61 +4818,13 @@ var app18 = new Hono18().post("/:name/chat", zValidator7("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-Z7O7PN2O.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 text = await res.text().catch(() => "");
-        console.error(`[chat] mind ${mindName} responded ${res.status}: ${text}`);
-      }
-    }).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");
@@ -4776,11 +4843,11 @@ var app18 = new Hono18().post("/:name/chat", zValidator7("json", chatSchema), as
         if (!stream.aborted) console.error("[chat] SSE ping error:", err);
       });
     }, 15e3);
-    await new Promise((resolve19) => {
+    await new Promise((resolve20) => {
       stream.onAbort(() => {
         unsubscribe();
         clearInterval(keepAlive);
-        resolve19();
+        resolve20();
       });
     });
   });
@@ -4790,7 +4857,7 @@ var unifiedChatSchema = z7.object({
   conversationId: z7.string(),
   images: z7.array(z7.object({ media_type: z7.string(), data: z7.string() })).optional()
 });
-var unifiedChatApp = new Hono18().post(
+var unifiedChatApp = new Hono20().post(
   "/chat",
   zValidator7("json", unifiedChatSchema),
   async (c) => {
@@ -4813,79 +4880,31 @@ var unifiedChatApp = new Hono18().post(
       }
     }
     await addMessage(body.conversationId, "user", senderName, contentBlocks);
-    const participants = await getParticipants(body.conversationId);
-    const mindParticipants = participants.filter((p) => p.userType === "mind");
-    const participantNames = participants.map((p) => p.username);
-    const { getMindManager: getMindManager2 } = await import("./mind-manager-Z7O7PN2O.js");
-    const manager = getMindManager2();
-    const runningMinds = mindParticipants.map((ap) => manager.isRunning(ap.username) ? ap.username : null).filter((n) => n !== null && n !== senderName);
-    const isDM = conv.type === "dm" && participants.length === 2;
-    const channelEntry = {
-      platformId: body.conversationId,
-      platform: "volute",
-      name: conv.title ?? void 0,
-      type: conv.type === "channel" ? "group" : isDM ? "dm" : "group"
-    };
-    for (const ap of mindParticipants) {
-      const slug = buildVoluteSlug({
-        participants,
-        mindUsername: ap.username,
-        convTitle: conv.title,
-        conversationId: conv.id,
-        convType: conv.type,
-        convName: conv.name
-      });
-      try {
-        writeChannelEntry(ap.username, slug, channelEntry);
-      } catch (err) {
-        console.warn(`[chat] failed to write channel entry for ${ap.username}:`, err);
-      }
-    }
-    for (const mindName of runningMinds) {
-      const channel = buildVoluteSlug({
-        participants,
-        mindUsername: mindName,
-        convTitle: conv.title,
-        conversationId: body.conversationId,
-        convType: conv.type,
-        convName: conv.name
-      });
-      const typingMap = getTypingMap();
-      const currentlyTyping = typingMap.get(channel);
-      const payload = JSON.stringify({
-        content: contentBlocks,
-        channel,
-        conversationId: body.conversationId,
-        sender: senderName,
-        participants: participantNames,
-        participantCount: participants.length,
-        isDM,
-        ...currentlyTyping.length > 0 ? { typing: currentlyTyping } : {}
-      });
-      daemonFetchInternal(`/api/minds/${encodeURIComponent(mindName)}/message`, payload).then(async (res) => {
-        if (!res.ok) {
-          const text = await res.text().catch(() => "");
-          console.error(`[chat] mind ${mindName} responded ${res.status}: ${text}`);
-        }
-      }).catch((err) => {
-        console.error(`[chat] mind ${mindName} unreachable via daemon:`, err);
-      });
-    }
+    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 = app18;
+var chat_default = app20;
 
 // src/web/api/volute/conversations.ts
 import { zValidator as zValidator8 } from "@hono/zod-validator";
-import { Hono as Hono19 } from "hono";
+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 app19 = new Hono19().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;
@@ -4970,18 +4989,18 @@ var app19 = new Hono19().get("/:name/conversations", async (c) => {
   if (!deleted) return c.json({ error: "Conversation not found" }, 404);
   return c.json({ ok: true });
 });
-var conversations_default = app19;
+var conversations_default = app21;
 
 // src/web/api/volute/user-conversations.ts
 import { zValidator as zValidator9 } from "@hono/zod-validator";
-import { Hono as Hono20 } from "hono";
+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 app20 = new Hono20().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);
@@ -5040,11 +5059,11 @@ var app20 = new Hono20().use("*", authMiddleware).get("/", async (c) => {
         if (!stream.aborted) console.error("[chat] SSE ping error:", err);
       });
     }, 15e3);
-    await new Promise((resolve19) => {
+    await new Promise((resolve20) => {
       stream.onAbort(() => {
         unsubscribe();
         clearInterval(keepAlive);
-        resolve19();
+        resolve20();
       });
     });
   });
@@ -5055,12 +5074,12 @@ var app20 = new Hono20().use("*", authMiddleware).get("/", async (c) => {
   if (!deleted) return c.json({ error: "Conversation not found" }, 404);
   return c.json({ ok: true });
 });
-var user_conversations_default = app20;
+var user_conversations_default = app22;
 
 // src/web/app.ts
 var httpLog = logger_default.child("http");
-var app21 = new Hono21();
-app21.onError((err, c) => {
+var app23 = new Hono23();
+app23.onError((err, c) => {
   if (err instanceof HTTPException) {
     return err.getResponse();
   }
@@ -5071,10 +5090,10 @@ app21.onError((err, c) => {
   });
   return c.json({ error: "Internal server error" }, 500);
 });
-app21.notFound((c) => {
+app23.notFound((c) => {
   return c.json({ error: "Not found" }, 404);
 });
-app21.use("*", async (c, next) => {
+app23.use("*", async (c, next) => {
   const start = Date.now();
   await next();
   const duration = Date.now() - start;
@@ -5085,7 +5104,7 @@ app21.use("*", async (c, next) => {
     httpLog.debug("request", data);
   }
 });
-app21.get("/api/health", (c) => {
+app23.get("/api/health", (c) => {
   let version = "unknown";
   let cached = null;
   try {
@@ -5100,18 +5119,18 @@ app21.get("/api/health", (c) => {
     ...cached?.updateAvailable ? { updateAvailable: true, latest: cached.latest } : {}
   });
 });
-app21.use("/api/*", bodyLimit({ maxSize: 10 * 1024 * 1024 }));
-app21.use("/api/*", csrf());
-app21.use("/api/minds/*", authMiddleware);
-app21.use("/api/conversations/*", authMiddleware);
-app21.use("/api/volute/*", authMiddleware);
-app21.use("/api/system/*", authMiddleware);
-app21.use("/api/env/*", authMiddleware);
-app21.use("/api/prompts/*", authMiddleware);
-app21.use("/api/skills/*", authMiddleware);
-app21.route("/pages", pages_default);
-var routes = app21.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", 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 = app21;
+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 = {
@@ -5128,20 +5147,20 @@ async function startServer({
   hostname = "127.0.0.1"
 }) {
   let assetsDir = "";
-  let searchDir = dirname2(new URL(import.meta.url).pathname);
+  let searchDir = dirname3(new URL(import.meta.url).pathname);
   for (let i = 0; i < 5; i++) {
-    const candidate = resolve17(searchDir, "dist", "web-assets");
-    if (existsSync11(candidate)) {
+    const candidate = resolve18(searchDir, "dist", "web-assets");
+    if (existsSync13(candidate)) {
       assetsDir = candidate;
       break;
     }
-    searchDir = dirname2(searchDir);
+    searchDir = dirname3(searchDir);
   }
   if (assetsDir) {
     app_default.get("*", async (c) => {
       const urlPath = new URL(c.req.url).pathname;
       if (urlPath.startsWith("/api/")) return c.notFound();
-      const filePath = resolve17(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()) {
@@ -5150,7 +5169,7 @@ async function startServer({
         const body = await readFile3(filePath);
         return c.body(body, 200, { "Content-Type": mime });
       }
-      const indexPath = resolve17(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");
@@ -5160,10 +5179,10 @@ async function startServer({
     });
   }
   const server = serve({ fetch: app_default.fetch, port, hostname });
-  await new Promise((resolve19, reject) => {
+  await new Promise((resolve20, reject) => {
     server.on("listening", () => {
       logger_default.info("Volute UI running", { hostname, port });
-      resolve19();
+      resolve20();
     });
     server.on("error", (err) => {
       reject(err);
@@ -5174,14 +5193,14 @@ async function startServer({
 
 // src/daemon.ts
 if (!process.env.VOLUTE_HOME) {
-  process.env.VOLUTE_HOME = resolve18(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(resolve18(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)}
@@ -5191,10 +5210,21 @@ async function startDaemon(opts) {
     console.warn = write;
     console.info = write;
   }
-  const DAEMON_PID_PATH = resolve18(home, "daemon.pid");
-  const DAEMON_JSON_PATH = resolve18(home, "daemon.json");
-  mkdirSync8(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);
@@ -5210,73 +5240,78 @@ async function startDaemon(opts) {
     }
     throw err;
   }
-  writeFileSync8(DAEMON_PID_PATH, myPid, { mode: 420 });
-  writeFileSync8(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 (readFileSync10(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(readFileSync10(DAEMON_JSON_PATH, "utf-8"));
+      const data = JSON.parse(readFileSync11(DAEMON_JSON_PATH, "utf-8"));
       if (data.token === token) {
         unlinkSync2(DAEMON_JSON_PATH);
       }
@@ -5292,6 +5327,7 @@ async function startDaemon(opts) {
     scheduler.saveState();
     mailPoller.stop();
     tokenBudget.stop();
+    delivery.dispose();
     await connectors.stopAll();
     await manager.stopAll();
     manager.clearCrashAttempts();