volute 0.19.0 → 0.20.0

package/dist/daemon.js

@@ -14,7 +14,7 @@ import {
   syncBuiltinSkills,
   uninstallSkill,
   updateSkill
-} from "./chunk-OTWLI7F4.js";
+} from "./chunk-IKMY5X76.js";
 import {
   addSharedWorktree,
   ensureSharedRepo,
@@ -23,17 +23,16 @@ import {
   sharedMerge,
   sharedPull,
   sharedStatus
-} from "./chunk-4KPUF5JD.js";
+} from "./chunk-TIWH32HP.js";
 import {
   readSystemsConfig
 } from "./chunk-FCDU5BFX.js";
 import {
-  deliverMessage,
-  extractTextContent,
-  getDeliveryManager,
-  getTypingMap,
-  initDeliveryManager
-} from "./chunk-FGV2H4TX.js";
+  getActiveMinds,
+  markIdle,
+  onMindEvent,
+  stopAll
+} from "./chunk-GZ7DW4YL.js";
 import {
   PROMPT_DEFAULTS,
   PROMPT_KEYS,
@@ -48,7 +47,22 @@ import {
   loadJsonMap,
   saveJsonMap,
   substitute
-} from "./chunk-2TJGRJ4O.js";
+} from "./chunk-PUVXOZ6T.js";
+import {
+  deliverMessage,
+  extractTextContent,
+  getDeliveryManager,
+  getTypingMap,
+  initDeliveryManager,
+  publish,
+  publishTypingForChannels,
+  subscribe
+} from "./chunk-FGSYHIS3.js";
+import {
+  broadcast,
+  publish as publish2,
+  subscribe as subscribe2
+} from "./chunk-UU7A7KLB.js";
 import {
   logBuffer,
   logger_default
@@ -64,7 +78,7 @@ import {
   parseNameFromIdentity,
   readVoluteConfig,
   writeVoluteConfig
-} from "./chunk-EMQSAY3B.js";
+} from "./chunk-O6ASDHFO.js";
 import {
   loadMergedEnv,
   mindEnvPath,
@@ -74,8 +88,9 @@ import {
 } from "./chunk-VDWCHYTS.js";
 import {
   getDb
-} from "./chunk-Z524RFCJ.js";
+} from "./chunk-5XNT2472.js";
 import {
+  activity,
   conversationParticipants,
   conversations,
   messages,
@@ -83,7 +98,7 @@ import {
   sessions,
   systemPrompts,
   users
-} from "./chunk-VQWDC6UK.js";
+} from "./chunk-NSE7VJQA.js";
 import "./chunk-D424ZQGI.js";
 import {
   exec,
@@ -135,10 +150,10 @@ import {
 import "./chunk-K3NQKI34.js";
 
 // src/daemon.ts
-import { randomBytes } from "crypto";
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync11, unlinkSync as unlinkSync2, writeFileSync as writeFileSync10 } from "fs";
+import { randomBytes as randomBytes2 } from "crypto";
+import { mkdirSync as mkdirSync11, readFileSync as readFileSync13, unlinkSync as unlinkSync2, writeFileSync as writeFileSync11 } from "fs";
 import { homedir as homedir2 } from "os";
-import { resolve as resolve19 } from "path";
+import { resolve as resolve22 } from "path";
 import { format } from "util";
 
 // src/lib/connector-manager.ts
@@ -382,19 +397,19 @@ var ConnectorManager = class {
     const stopKey = `${mindName}:${type}`;
     this.stopping.add(stopKey);
     mindMap.delete(type);
-    await new Promise((resolve20) => {
-      tracked.child.on("exit", () => resolve20());
+    await new Promise((resolve23) => {
+      tracked.child.on("exit", () => resolve23());
       try {
         tracked.child.kill("SIGTERM");
       } catch {
-        resolve20();
+        resolve23();
       }
       setTimeout(() => {
         try {
           tracked.child.kill("SIGKILL");
         } catch {
         }
-        resolve20();
+        resolve23();
       }, 5e3);
     });
     this.stopping.delete(stopKey);
@@ -885,8 +900,213 @@ function migrateMindState(name) {
   }
 }
 
+// src/lib/pages-watcher.ts
+import { existsSync as existsSync5, readdirSync as readdirSync2, statSync, watch } from "fs";
+import { join, resolve as resolve5 } from "path";
+var watchers = /* @__PURE__ */ new Map();
+var homeWatchers = /* @__PURE__ */ new Map();
+var debounceTimers = /* @__PURE__ */ new Map();
+var sitesCache = null;
+var recentPagesCache = null;
+function startPagesWatcher(mindName, pagesDir) {
+  try {
+    const watcher = watch(pagesDir, { recursive: true }, (_eventType, filename) => {
+      if (!filename || !filename.endsWith(".html")) return;
+      const key = `${mindName}:${filename}`;
+      const existing = debounceTimers.get(key);
+      if (existing) clearTimeout(existing);
+      debounceTimers.set(
+        key,
+        setTimeout(() => {
+          debounceTimers.delete(key);
+          invalidateCache();
+          publish2({
+            type: "page_updated",
+            mind: mindName,
+            summary: `${mindName} updated ${filename}`,
+            metadata: { file: filename }
+          }).catch(
+            (err) => logger_default.error("failed to publish page_updated activity", logger_default.errorData(err))
+          );
+        }, 100)
+      );
+    });
+    watchers.set(mindName, watcher);
+  } catch (err) {
+    logger_default.warn(`failed to start pages watcher for ${mindName}`, logger_default.errorData(err));
+  }
+}
+function startWatcher(mindName) {
+  if (watchers.has(mindName)) return;
+  const pagesDir = resolve5(mindDir(mindName), "home", "pages");
+  if (existsSync5(pagesDir)) {
+    startPagesWatcher(mindName, pagesDir);
+    return;
+  }
+  if (homeWatchers.has(mindName)) return;
+  const homeDir = resolve5(mindDir(mindName), "home");
+  if (!existsSync5(homeDir)) return;
+  try {
+    const hw = watch(homeDir, (_eventType, filename) => {
+      if (filename !== "pages") return;
+      if (!existsSync5(pagesDir)) return;
+      hw.close();
+      homeWatchers.delete(mindName);
+      invalidateCache();
+      startPagesWatcher(mindName, pagesDir);
+    });
+    homeWatchers.set(mindName, hw);
+  } catch (err) {
+    logger_default.warn(`failed to start home watcher for ${mindName}`, logger_default.errorData(err));
+  }
+}
+function stopWatcher(mindName) {
+  const watcher = watchers.get(mindName);
+  if (watcher) {
+    watcher.close();
+    watchers.delete(mindName);
+  }
+  const hw = homeWatchers.get(mindName);
+  if (hw) {
+    hw.close();
+    homeWatchers.delete(mindName);
+  }
+  for (const [key, timer] of debounceTimers) {
+    if (key.startsWith(`${mindName}:`)) {
+      clearTimeout(timer);
+      debounceTimers.delete(key);
+    }
+  }
+}
+function stopAllWatchers() {
+  for (const [, watcher] of watchers) {
+    watcher.close();
+  }
+  watchers.clear();
+  for (const [, hw] of homeWatchers) {
+    hw.close();
+  }
+  homeWatchers.clear();
+  for (const [, timer] of debounceTimers) {
+    clearTimeout(timer);
+  }
+  debounceTimers.clear();
+  invalidateCache();
+}
+function invalidateCache() {
+  sitesCache = null;
+  recentPagesCache = null;
+}
+function scanPagesDir(dir, urlPrefix) {
+  const pages = [];
+  let items;
+  try {
+    items = readdirSync2(dir);
+  } catch {
+    return pages;
+  }
+  for (const item of items) {
+    if (item.startsWith(".")) continue;
+    const fullPath = resolve5(dir, item);
+    try {
+      const s = statSync(fullPath);
+      if (s.isFile() && item.endsWith(".html")) {
+        pages.push({
+          file: item,
+          modified: s.mtime.toISOString(),
+          url: `${urlPrefix}/${item}`
+        });
+      } else if (s.isDirectory()) {
+        const indexPath = resolve5(fullPath, "index.html");
+        if (existsSync5(indexPath)) {
+          const indexStat = statSync(indexPath);
+          pages.push({
+            file: join(item, "index.html"),
+            modified: indexStat.mtime.toISOString(),
+            url: `${urlPrefix}/${item}/`
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  pages.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
+  return pages;
+}
+function buildSites() {
+  const sites = [];
+  const systemPagesDir = resolve5(voluteHome(), "shared", "pages");
+  if (existsSync5(systemPagesDir)) {
+    const systemPages = scanPagesDir(systemPagesDir, "/pages/_system");
+    if (systemPages.length > 0) {
+      sites.push({ name: "_system", label: "System", pages: systemPages });
+    }
+  }
+  const entries = readRegistry();
+  for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
+    const pagesDir = resolve5(mindDir(entry.name), "home", "pages");
+    if (!existsSync5(pagesDir)) continue;
+    const mindPages = scanPagesDir(pagesDir, `/pages/${entry.name}`);
+    if (mindPages.length > 0) {
+      sites.push({ name: entry.name, label: entry.name, pages: mindPages });
+    }
+  }
+  return sites;
+}
+function buildRecentPages() {
+  const entries = readRegistry();
+  const pages = [];
+  for (const entry of entries) {
+    const pagesDir = resolve5(mindDir(entry.name), "home", "pages");
+    if (!existsSync5(pagesDir)) continue;
+    let items;
+    try {
+      items = readdirSync2(pagesDir);
+    } catch {
+      continue;
+    }
+    for (const item of items) {
+      if (item.startsWith(".")) continue;
+      const fullPath = resolve5(pagesDir, item);
+      try {
+        const s = statSync(fullPath);
+        if (s.isFile() && item.endsWith(".html")) {
+          pages.push({
+            mind: entry.name,
+            file: item,
+            modified: s.mtime.toISOString(),
+            url: `/pages/${entry.name}/${item}`
+          });
+        } else if (s.isDirectory()) {
+          const indexPath = resolve5(fullPath, "index.html");
+          if (existsSync5(indexPath)) {
+            const indexStat = statSync(indexPath);
+            pages.push({
+              mind: entry.name,
+              file: join(item, "index.html"),
+              modified: indexStat.mtime.toISOString(),
+              url: `/pages/${entry.name}/${item}/`
+            });
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  pages.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
+  return pages.slice(0, 10);
+}
+function getCachedSites() {
+  if (!sitesCache) sitesCache = buildSites();
+  return sitesCache;
+}
+function getCachedRecentPages() {
+  if (!recentPagesCache) recentPagesCache = buildRecentPages();
+  return recentPagesCache;
+}
+
 // src/lib/scheduler.ts
-import { resolve as resolve5 } from "path";
+import { resolve as resolve6 } from "path";
 import { CronExpressionParser } from "cron-parser";
 var slog = logger_default.child("scheduler");
 var Scheduler = class {
@@ -895,7 +1115,7 @@ var Scheduler = class {
   lastFired = /* @__PURE__ */ new Map();
   // "mind:scheduleId" → epoch minute
   get statePath() {
-    return resolve5(voluteHome(), "scheduler-state.json");
+    return resolve6(voluteHome(), "scheduler-state.json");
   }
   start() {
     this.loadState();
@@ -959,8 +1179,30 @@ var Scheduler = class {
   }
   async fire(mindName, schedule) {
     try {
-      await deliverMessage(mindName, {
-        content: [{ type: "text", text: schedule.message }],
+      let text;
+      if (schedule.script) {
+        const homeDir = resolve6(mindDir(mindName), "home");
+        try {
+          const output = await this.runScript(schedule.script, homeDir, mindName);
+          if (!output.trim()) {
+            slog.info(`fired script "${schedule.id}" for ${mindName} (no output)`);
+            return;
+          }
+          text = output;
+        } catch (err) {
+          const stderr = err.stderr ?? "";
+          text = `[script error] ${err.message}${stderr ? `
+${stderr}` : ""}`;
+          slog.warn(`script "${schedule.id}" failed for ${mindName}`, logger_default.errorData(err));
+        }
+      } else if (schedule.message) {
+        text = schedule.message;
+      } else {
+        slog.warn(`schedule "${schedule.id}" for ${mindName} has no message or script`);
+        return;
+      }
+      await this.deliver(mindName, {
+        content: [{ type: "text", text }],
         channel: "system:scheduler",
         sender: schedule.id
       });
@@ -969,6 +1211,12 @@ var Scheduler = class {
       slog.warn(`failed to fire "${schedule.id}" for ${mindName}`, logger_default.errorData(err));
     }
   }
+  runScript(script, cwd, mindName) {
+    return exec("bash", ["-c", script], { cwd, mindName });
+  }
+  deliver(mindName, payload) {
+    return deliverMessage(mindName, payload);
+  }
 };
 var instance3 = null;
 function initScheduler() {
@@ -982,8 +1230,8 @@ function getScheduler() {
 }
 
 // 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";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolve7 } from "path";
 var tlog = logger_default.child("token-budget");
 var DEFAULT_BUDGET_PERIOD_MINUTES = 60;
 var MAX_QUEUE_SIZE = 100;
@@ -1090,7 +1338,7 @@ var TokenBudget = class {
     }
   }
   budgetStatePath(mind) {
-    return resolve6(stateDir(mind), "budget.json");
+    return resolve7(stateDir(mind), "budget.json");
   }
   saveBudgetState(mind, state) {
     try {
@@ -1111,7 +1359,7 @@ var TokenBudget = class {
   loadBudgetState(mind) {
     try {
       const path = this.budgetStatePath(mind);
-      if (!existsSync5(path)) return null;
+      if (!existsSync6(path)) return null;
       const data = JSON.parse(readFileSync4(path, "utf-8"));
       if (typeof data.periodStart !== "number" || typeof data.tokensUsed !== "number") return null;
       return {
@@ -1171,6 +1419,11 @@ function getTokenBudget() {
 async function startMindFull(name) {
   const [baseName, variantName] = name.split("@", 2);
   await getMindManager().startMind(name);
+  publish2({
+    type: "mind_started",
+    mind: name,
+    summary: `${name} started`
+  }).catch((err) => logger_default.error("failed to publish mind_started activity", logger_default.errorData(err)));
   if (variantName) return;
   const entry = findMind(baseName);
   if (!entry || entry.stage === "seed") return;
@@ -1189,15 +1442,23 @@ async function startMindFull(name) {
       config.tokenBudgetPeriodMinutes ?? DEFAULT_BUDGET_PERIOD_MINUTES
     );
   }
+  startWatcher(baseName);
 }
 async function stopMindFull(name) {
   const [baseName, variantName] = name.split("@", 2);
   if (!variantName) {
+    stopWatcher(baseName);
+    markIdle(baseName);
     await getConnectorManager().stopConnectors(baseName);
     getScheduler().unloadSchedules(baseName);
     getTokenBudget().removeBudget(baseName);
   }
   await getMindManager().stopMind(name);
+  publish2({
+    type: "mind_stopped",
+    mind: name,
+    summary: `${name} stopped`
+  }).catch((err) => logger_default.error("failed to publish mind_stopped activity", logger_default.errorData(err)));
 }
 
 // src/web/middleware/auth.ts
@@ -1418,136 +1679,464 @@ var authMiddleware = createMiddleware(async (c, next) => {
 });
 
 // src/web/server.ts
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { readFile as readFile3, stat as stat2 } from "fs/promises";
-import { dirname as dirname3, extname as extname2, resolve as resolve18 } from "path";
+import { dirname as dirname3, extname as extname2, resolve as resolve21 } from "path";
 import { serve } from "@hono/node-server";
 
 // src/web/app.ts
-import { Hono as Hono23 } from "hono";
+import { Hono as Hono25 } from "hono";
 import { bodyLimit } from "hono/body-limit";
 import { csrf } from "hono/csrf";
 import { HTTPException } from "hono/http-exception";
 
-// src/web/api/auth.ts
-import { zValidator } from "@hono/zod-validator";
+// src/web/api/activity.ts
+import { desc as desc2 } from "drizzle-orm";
 import { Hono } from "hono";
-import { deleteCookie, getCookie as getCookie2, setCookie } from "hono/cookie";
-import { z } from "zod";
-var credentialsSchema = z.object({
-  username: z.string().min(1),
-  password: z.string().min(1)
-});
-var changePasswordSchema = z.object({
-  currentPassword: z.string().min(1),
-  newPassword: z.string().min(1)
-});
-var authenticated = new Hono().use(authMiddleware).post("/change-password", zValidator("json", changePasswordSchema), async (c) => {
-  const user = c.get("user");
-  const { currentPassword, newPassword } = c.req.valid("json");
-  const ok = await changePassword(user.id, currentPassword, newPassword);
-  if (!ok) return c.json({ error: "Current password is incorrect" }, 400);
-  return c.json({ ok: true });
-});
-var admin = new Hono().use(authMiddleware).get("/users", async (c) => {
-  const user = c.get("user");
-  if (user.role !== "admin") return c.json({ error: "Forbidden" }, 403);
-  const minds = readRegistry();
-  for (const mind of minds) {
-    await getOrCreateMindUser(mind.name);
-  }
-  const type = c.req.query("type");
-  if (type === "brain" || type === "mind") {
-    return c.json(await listUsersByType(type));
-  }
-  return c.json(await listUsers());
-}).get("/users/pending", async (c) => {
-  const user = c.get("user");
-  if (user.role !== "admin") return c.json({ error: "Forbidden" }, 403);
-  return c.json(await listPendingUsers());
-}).post("/users/:id/approve", async (c) => {
-  const user = c.get("user");
-  if (user.role !== "admin") return c.json({ error: "Forbidden" }, 403);
-  const id = parseInt(c.req.param("id"), 10);
-  await approveUser(id);
-  return c.json({ ok: true });
-});
-var app = new Hono().post("/register", zValidator("json", credentialsSchema), async (c) => {
-  const { username, password } = c.req.valid("json");
-  const existing = await getUserByUsername(username);
-  if (existing) {
-    return c.json({ error: "Username already taken" }, 409);
-  }
-  const user = await createUser(username, password);
-  if (user.role === "admin") {
-    const sessionId = await createSession(user.id);
-    setCookie(c, "volute_session", sessionId, { path: "/", httpOnly: true, sameSite: "Lax" });
-  }
-  return c.json({ id: user.id, username: user.username, role: user.role });
-}).post("/login", zValidator("json", credentialsSchema), async (c) => {
-  const { username, password } = c.req.valid("json");
-  const user = await verifyUser(username, password);
-  if (!user) {
-    return c.json({ error: "Invalid credentials" }, 401);
-  }
-  const sessionId = await createSession(user.id);
-  setCookie(c, "volute_session", sessionId, { path: "/", httpOnly: true, sameSite: "Lax" });
-  return c.json({ id: user.id, username: user.username, role: user.role });
-}).post("/logout", async (c) => {
-  const sessionId = getCookie2(c, "volute_session");
-  if (sessionId) {
-    await deleteSession(sessionId);
-    deleteCookie(c, "volute_session", { path: "/" });
-  }
-  return c.json({ ok: true });
-}).get("/me", async (c) => {
-  const sessionId = getCookie2(c, "volute_session");
-  if (!sessionId) return c.json({ error: "Not logged in" }, 401);
-  const userId = await getSessionUserId(sessionId);
-  if (userId == null) return c.json({ error: "Not logged in" }, 401);
-  const user = await getUser(userId);
-  if (!user) return c.json({ error: "Not logged in" }, 401);
-  return c.json({ id: user.id, username: user.username, role: user.role });
-}).route("/", admin).route("/", authenticated);
-var auth_default = app;
+import { streamSSE } from "hono/streaming";
 
-// src/web/api/channels.ts
-import { Hono as Hono2 } from "hono";
-function buildEnv(name) {
-  return { ...loadMergedEnv(name), VOLUTE_MIND: name, VOLUTE_MIND_DIR: mindDir(name) };
+// src/lib/conversations.ts
+import { randomUUID } from "crypto";
+import { and as and2, desc, eq as eq3, inArray, isNull, sql } from "drizzle-orm";
+async function createConversation(mindName, channel, opts) {
+  const db = await getDb();
+  const id = randomUUID();
+  const type = opts?.type ?? "dm";
+  const name = opts?.name ?? null;
+  await db.transaction(async (tx) => {
+    await tx.insert(conversations).values({
+      id,
+      mind_name: mindName,
+      channel,
+      type,
+      name,
+      user_id: opts?.userId ?? null,
+      title: opts?.title ?? null
+    });
+    if (opts?.participantIds && opts.participantIds.length > 0) {
+      await tx.insert(conversationParticipants).values(
+        opts.participantIds.map((uid, i) => ({
+          conversation_id: id,
+          user_id: uid,
+          role: i === 0 ? "owner" : "member"
+        }))
+      );
+    }
+  });
+  return {
+    id,
+    mind_name: mindName,
+    channel,
+    type,
+    name,
+    user_id: opts?.userId ?? null,
+    title: opts?.title ?? null,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
 }
-var app2 = new Hono2().post("/:name/channels/send", requireAdmin, async (c) => {
-  const name = c.req.param("name");
-  if (!findMind(name)) return c.json({ error: "Mind not found" }, 404);
-  const { platform, uri, message, images } = await c.req.json();
-  const driver = getChannelDriver(platform);
-  if (!driver) return c.json({ error: `No driver for platform: ${platform}` }, 400);
-  const env = buildEnv(name);
-  try {
-    await driver.send(env, uri, message, images);
-    return c.json({ ok: true });
-  } catch (err) {
-    return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
-  }
-}).get("/:name/channels/read", async (c) => {
-  const name = c.req.param("name");
-  if (!findMind(name)) return c.json({ error: "Mind not found" }, 404);
-  const platform = c.req.query("platform");
-  const uri = c.req.query("uri");
-  const limit = parseInt(c.req.query("limit") ?? "20", 10) || 20;
-  if (!platform || !uri) return c.json({ error: "platform and uri required" }, 400);
-  const driver = getChannelDriver(platform);
-  if (!driver) return c.json({ error: `No driver for platform: ${platform}` }, 400);
-  const env = buildEnv(name);
-  try {
-    const output = await driver.read(env, uri, limit);
-    return c.text(output);
-  } catch (err) {
-    return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
-  }
-}).get("/:name/channels/list", async (c) => {
-  const name = c.req.param("name");
-  if (!findMind(name)) return c.json({ error: "Mind not found" }, 404);
+async function getConversation(id) {
+  const db = await getDb();
+  const row = await db.select().from(conversations).where(eq3(conversations.id, id)).get();
+  return row ?? null;
+}
+async function addParticipant(conversationId, userId, role = "member") {
+  const db = await getDb();
+  await db.insert(conversationParticipants).values({
+    conversation_id: conversationId,
+    user_id: userId,
+    role
+  });
+}
+async function removeParticipant(conversationId, userId) {
+  const db = await getDb();
+  await db.delete(conversationParticipants).where(
+    and2(
+      eq3(conversationParticipants.conversation_id, conversationId),
+      eq3(conversationParticipants.user_id, userId)
+    )
+  );
+}
+async function getParticipants(conversationId) {
+  const db = await getDb();
+  const rows = await db.select({
+    userId: conversationParticipants.user_id,
+    username: users.username,
+    userType: users.user_type,
+    role: conversationParticipants.role
+  }).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(
+      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(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();
+}
+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(eq3(conversations.id, conversationId), eq3(conversations.user_id, userId))).get();
+  return row != null;
+}
+async function deleteConversationForUser(id, userId) {
+  if (!await isParticipantOrOwner(id, userId)) return false;
+  await deleteConversation(id);
+  return true;
+}
+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: 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(eq3(conversations.id, conversationId), isNull(conversations.title)));
+    }
+  }
+  const msg = {
+    id: result.id,
+    conversation_id: conversationId,
+    role,
+    sender_name: senderName,
+    content,
+    created_at: result.created_at
+  };
+  publish(conversationId, {
+    type: "message",
+    id: msg.id,
+    role: msg.role,
+    senderName: msg.sender_name,
+    content: msg.content,
+    createdAt: msg.created_at
+  });
+  return msg;
+}
+async function getMessages(conversationId) {
+  const db = await getDb();
+  const rows = await db.select().from(messages).where(eq3(messages.conversation_id, conversationId)).orderBy(messages.created_at).all();
+  return rows.map((row) => {
+    let content;
+    try {
+      const parsed = JSON.parse(row.content);
+      content = Array.isArray(parsed) ? parsed : [{ type: "text", text: row.content }];
+    } catch {
+      content = [{ type: "text", text: row.content }];
+    }
+    return { ...row, content };
+  });
+}
+async function listConversationsWithParticipants(userId) {
+  const convs = await listConversationsForUser(userId);
+  if (convs.length === 0) return [];
+  const db = await getDb();
+  const convIds = convs.map((c) => c.id);
+  const rows = await db.select({
+    conversationId: conversationParticipants.conversation_id,
+    userId: users.id,
+    username: users.username,
+    userType: users.user_type,
+    role: conversationParticipants.role
+  }).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);
+    if (!arr) {
+      arr = [];
+      byConv.set(r.conversationId, arr);
+    }
+    arr.push({
+      userId: r.userId,
+      username: r.username,
+      userType: r.userType,
+      role: r.role
+    });
+  }
+  const lastMsgIds = await db.select({
+    conversationId: messages.conversation_id,
+    maxId: sql`MAX(${messages.id})`
+  }).from(messages).where(inArray(messages.conversation_id, convIds)).groupBy(messages.conversation_id);
+  const byLastMsg = /* @__PURE__ */ new Map();
+  if (lastMsgIds.length > 0) {
+    const msgRows = await db.select().from(messages).where(
+      inArray(
+        messages.id,
+        lastMsgIds.map((r) => r.maxId)
+      )
+    );
+    for (const m of msgRows) {
+      let text = "";
+      try {
+        const parsed = JSON.parse(m.content);
+        const blocks = Array.isArray(parsed) ? parsed : [];
+        const textBlock = blocks.find((b) => b.type === "text");
+        if (textBlock && "text" in textBlock) text = textBlock.text;
+      } catch {
+        text = m.content;
+      }
+      byLastMsg.set(m.conversation_id, {
+        role: m.role,
+        senderName: m.sender_name,
+        text,
+        createdAt: m.created_at
+      });
+    }
+  }
+  return convs.map((c) => ({
+    ...c,
+    participants: byConv.get(c.id) ?? [],
+    lastMessage: byLastMsg.get(c.id)
+  }));
+}
+async function findDMConversation(mindName, participantIds) {
+  const db = await getDb();
+  const mindConvs = await db.select({ id: conversations.id }).from(conversations).where(and2(eq3(conversations.mind_name, mindName), eq3(conversations.type, "dm"))).all();
+  for (const conv of mindConvs) {
+    const rows = await 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])) {
+      return conv.id;
+    }
+  }
+  return null;
+}
+async function deleteConversation(id) {
+  const db = await getDb();
+  await db.delete(conversations).where(eq3(conversations.id, id));
+}
+async function createChannel(name, creatorId) {
+  const participantIds = creatorId ? [creatorId] : [];
+  return createConversation(null, "volute", {
+    type: "channel",
+    name,
+    title: name,
+    participantIds
+  });
+}
+async function getChannelByName(name) {
+  const db = await getDb();
+  const row = await db.select().from(conversations).where(and2(eq3(conversations.name, name), eq3(conversations.type, "channel"))).get();
+  return row ?? null;
+}
+async function listChannels() {
+  const db = await getDb();
+  return await db.select().from(conversations).where(eq3(conversations.type, "channel")).orderBy(conversations.name).all();
+}
+async function joinChannel(conversationId, userId) {
+  if (await isParticipant(conversationId, userId)) return;
+  await addParticipant(conversationId, userId);
+}
+async function leaveChannel(conversationId, userId) {
+  await removeParticipant(conversationId, userId);
+}
+
+// src/web/api/activity.ts
+var app = new Hono().get("/events", async (c) => {
+  const user = c.get("user");
+  return streamSSE(c, async (stream) => {
+    const cleanups = [];
+    try {
+      let recentActivity = [];
+      try {
+        const db = await getDb();
+        recentActivity = await db.select().from(activity).orderBy(desc2(activity.created_at)).limit(50);
+        recentActivity = recentActivity.map((row) => ({
+          ...row,
+          metadata: row.metadata ? JSON.parse(row.metadata) : null
+        }));
+      } catch (err) {
+        logger_default.error("[activity-sse] failed to fetch recent activity", logger_default.errorData(err));
+      }
+      let conversations2 = [];
+      try {
+        conversations2 = await listConversationsWithParticipants(user.id);
+      } catch (err) {
+        logger_default.error("[activity-sse] failed to fetch conversations", logger_default.errorData(err));
+      }
+      const sites = getCachedSites();
+      const recentPages = getCachedRecentPages();
+      await stream.writeSSE({
+        data: JSON.stringify({
+          event: "snapshot",
+          activity: recentActivity,
+          conversations: conversations2,
+          sites,
+          recentPages,
+          activeMinds: getActiveMinds()
+        })
+      });
+      const unsubActivity = subscribe2((event) => {
+        stream.writeSSE({
+          data: JSON.stringify({ event: "activity", ...event })
+        }).catch((err) => {
+          if (!stream.aborted) logger_default.error("[activity-sse] write error:", logger_default.errorData(err));
+        });
+      });
+      cleanups.push(unsubActivity);
+      for (const conv of conversations2) {
+        const unsubConv = subscribe(conv.id, (event) => {
+          stream.writeSSE({
+            data: JSON.stringify({ event: "conversation", conversationId: conv.id, ...event })
+          }).catch((err) => {
+            if (!stream.aborted) logger_default.error("[activity-sse] write error:", logger_default.errorData(err));
+          });
+        });
+        cleanups.push(unsubConv);
+      }
+      const keepAlive = setInterval(() => {
+        stream.writeSSE({ data: "" }).catch((err) => {
+          if (!stream.aborted) logger_default.error("[activity-sse] ping error:", logger_default.errorData(err));
+        });
+      }, 15e3);
+      cleanups.push(() => clearInterval(keepAlive));
+      await new Promise((resolve23) => {
+        stream.onAbort(() => resolve23());
+      });
+    } finally {
+      for (const cleanup of cleanups) {
+        try {
+          cleanup();
+        } catch {
+        }
+      }
+    }
+  });
+});
+var activity_default = app;
+
+// src/web/api/auth.ts
+import { zValidator } from "@hono/zod-validator";
+import { Hono as Hono2 } from "hono";
+import { deleteCookie, getCookie as getCookie2, setCookie } from "hono/cookie";
+import { z } from "zod";
+var credentialsSchema = z.object({
+  username: z.string().min(1),
+  password: z.string().min(1)
+});
+var changePasswordSchema = z.object({
+  currentPassword: z.string().min(1),
+  newPassword: z.string().min(1)
+});
+var authenticated = new Hono2().use(authMiddleware).post("/change-password", zValidator("json", changePasswordSchema), async (c) => {
+  const user = c.get("user");
+  const { currentPassword, newPassword } = c.req.valid("json");
+  const ok = await changePassword(user.id, currentPassword, newPassword);
+  if (!ok) return c.json({ error: "Current password is incorrect" }, 400);
+  return c.json({ ok: true });
+});
+var admin = new Hono2().use(authMiddleware).get("/users", async (c) => {
+  const user = c.get("user");
+  if (user.role !== "admin") return c.json({ error: "Forbidden" }, 403);
+  const minds = readRegistry();
+  for (const mind of minds) {
+    await getOrCreateMindUser(mind.name);
+  }
+  const type = c.req.query("type");
+  if (type === "brain" || type === "mind") {
+    return c.json(await listUsersByType(type));
+  }
+  return c.json(await listUsers());
+}).get("/users/pending", async (c) => {
+  const user = c.get("user");
+  if (user.role !== "admin") return c.json({ error: "Forbidden" }, 403);
+  return c.json(await listPendingUsers());
+}).post("/users/:id/approve", async (c) => {
+  const user = c.get("user");
+  if (user.role !== "admin") return c.json({ error: "Forbidden" }, 403);
+  const id = parseInt(c.req.param("id"), 10);
+  await approveUser(id);
+  return c.json({ ok: true });
+});
+var app2 = new Hono2().post("/register", zValidator("json", credentialsSchema), async (c) => {
+  const { username, password } = c.req.valid("json");
+  const existing = await getUserByUsername(username);
+  if (existing) {
+    return c.json({ error: "Username already taken" }, 409);
+  }
+  const user = await createUser(username, password);
+  if (user.role === "admin") {
+    const sessionId = await createSession(user.id);
+    setCookie(c, "volute_session", sessionId, { path: "/", httpOnly: true, sameSite: "Lax" });
+  }
+  return c.json({ id: user.id, username: user.username, role: user.role });
+}).post("/login", zValidator("json", credentialsSchema), async (c) => {
+  const { username, password } = c.req.valid("json");
+  const user = await verifyUser(username, password);
+  if (!user) {
+    return c.json({ error: "Invalid credentials" }, 401);
+  }
+  const sessionId = await createSession(user.id);
+  setCookie(c, "volute_session", sessionId, { path: "/", httpOnly: true, sameSite: "Lax" });
+  return c.json({ id: user.id, username: user.username, role: user.role });
+}).post("/logout", async (c) => {
+  const sessionId = getCookie2(c, "volute_session");
+  if (sessionId) {
+    await deleteSession(sessionId);
+    deleteCookie(c, "volute_session", { path: "/" });
+  }
+  return c.json({ ok: true });
+}).get("/me", async (c) => {
+  const sessionId = getCookie2(c, "volute_session");
+  if (!sessionId) return c.json({ error: "Not logged in" }, 401);
+  const userId = await getSessionUserId(sessionId);
+  if (userId == null) return c.json({ error: "Not logged in" }, 401);
+  const user = await getUser(userId);
+  if (!user) return c.json({ error: "Not logged in" }, 401);
+  return c.json({ id: user.id, username: user.username, role: user.role });
+}).route("/", admin).route("/", authenticated);
+var auth_default = app2;
+
+// src/web/api/channels.ts
+import { Hono as Hono3 } from "hono";
+function buildEnv(name) {
+  return { ...loadMergedEnv(name), VOLUTE_MIND: name, VOLUTE_MIND_DIR: mindDir(name) };
+}
+var app3 = new Hono3().post("/:name/channels/send", requireAdmin, async (c) => {
+  const name = c.req.param("name");
+  if (!findMind(name)) return c.json({ error: "Mind not found" }, 404);
+  const { platform, uri, message, images } = await c.req.json();
+  const driver = getChannelDriver(platform);
+  if (!driver) return c.json({ error: `No driver for platform: ${platform}` }, 400);
+  const env = buildEnv(name);
+  try {
+    await driver.send(env, uri, message, images);
+    return c.json({ ok: true });
+  } catch (err) {
+    return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+  }
+}).get("/:name/channels/read", async (c) => {
+  const name = c.req.param("name");
+  if (!findMind(name)) return c.json({ error: "Mind not found" }, 404);
+  const platform = c.req.query("platform");
+  const uri = c.req.query("uri");
+  const limit = parseInt(c.req.query("limit") ?? "20", 10) || 20;
+  if (!platform || !uri) return c.json({ error: "platform and uri required" }, 400);
+  const driver = getChannelDriver(platform);
+  if (!driver) return c.json({ error: `No driver for platform: ${platform}` }, 400);
+  const env = buildEnv(name);
+  try {
+    const output = await driver.read(env, uri, limit);
+    return c.text(output);
+  } catch (err) {
+    return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+  }
+}).get("/:name/channels/list", async (c) => {
+  const name = c.req.param("name");
+  if (!findMind(name)) return c.json({ error: "Mind not found" }, 404);
   const platform = c.req.query("platform");
   const platforms = platform ? [platform] : Object.keys(CHANNELS);
   const env = buildEnv(name);
@@ -1606,12 +2195,12 @@ var app2 = new Hono2().post("/:name/channels/send", requireAdmin, async (c) => {
     return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
   }
 });
-var channels_default = app2;
+var channels_default = app3;
 
 // src/web/api/connectors.ts
-import { Hono as Hono3 } from "hono";
+import { Hono as Hono4 } from "hono";
 var CONNECTOR_TYPE_RE = /^[a-z][a-z0-9-]*$/;
-var app3 = new Hono3().get("/:name/connectors", (c) => {
+var app4 = new Hono4().get("/:name/connectors", (c) => {
   const name = c.req.param("name");
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
@@ -1685,11 +2274,11 @@ var app3 = new Hono3().get("/:name/connectors", (c) => {
   writeVoluteConfig(dir, config);
   return c.json({ ok: true });
 });
-var connectors_default = app3;
+var connectors_default = app4;
 
 // src/web/api/env.ts
-import { Hono as Hono4 } from "hono";
-var app4 = new Hono4().get("/:name/env", (c) => {
+import { Hono as Hono5 } from "hono";
+var app5 = new Hono5().get("/:name/env", (c) => {
   const name = c.req.param("name");
   if (!findMind(name)) return c.json({ error: "Mind not found" }, 404);
   const shared = readEnv(sharedEnvPath());
@@ -1732,7 +2321,7 @@ var app4 = new Hono4().get("/:name/env", (c) => {
   writeEnv(path, env);
   return c.json({ ok: true });
 });
-var sharedEnvApp = new Hono4().get("/", (c) => {
+var sharedEnvApp = new Hono5().get("/", (c) => {
   return c.json(readEnv(sharedEnvPath()));
 }).put("/:key", requireAdmin, async (c) => {
   const key = c.req.param("key");
@@ -1759,644 +2348,670 @@ var sharedEnvApp = new Hono4().get("/", (c) => {
   writeEnv(path, env);
   return c.json({ ok: true });
 });
-var env_default = app4;
-
-// src/web/api/files.ts
-import { existsSync as existsSync6 } from "fs";
-import { readdir, readFile } from "fs/promises";
-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) => {
-  const name = c.req.param("name");
-  const entry = findMind(name);
-  if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const dir = mindDir(name);
-  const homeDir = 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);
-}).get("/:name/files/:filename", async (c) => {
-  const name = c.req.param("name");
-  const filename = c.req.param("filename");
-  if (!ALLOWED_FILES.has(filename)) {
-    return c.json({ error: "File not allowed" }, 403);
-  }
-  const entry = findMind(name);
-  if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const dir = mindDir(name);
-  const filePath = resolve7(dir, "home", filename);
-  if (!existsSync6(filePath)) {
-    return c.json({ error: "File not found" }, 404);
-  }
-  const content = await readFile(filePath, "utf-8");
-  return c.json({ filename, content });
-});
-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;
+var env_default = app5;
 
-// src/web/api/logs.ts
-import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync8 } from "fs";
+// src/web/api/file-sharing.ts
+import { readFileSync as readFileSync6, statSync as statSync2 } from "fs";
 import { resolve as resolve9 } from "path";
-import { Hono as Hono7 } from "hono";
-import { streamSSE } from "hono/streaming";
-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 = resolve9(stateDir(name), "logs", "mind.log");
-  if (!existsSync8(logFile)) {
-    return c.json({ error: "No log file found" }, 404);
-  }
-  return streamSSE(c, async (stream) => {
-    const tail = spawn2("tail", ["-n", "200", "-f", logFile]);
-    const onData = (data) => {
-      const lines = data.toString().split("\n");
-      for (const line of lines) {
-        if (line) {
-          stream.writeSSE({ data: line }).catch(() => {
-          });
-        }
-      }
-    };
-    tail.stdout.on("data", onData);
-    stream.onAbort(() => {
-      tail.kill();
-    });
-    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 = 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);
-  const n = Number.isFinite(nParam) && nParam > 0 ? Math.min(nParam, 1e4) : 50;
-  const tail = spawn2("tail", ["-n", String(n), logFile]);
-  let output = "";
-  tail.stdout.on("data", (data) => {
-    output += data.toString();
-  });
-  await new Promise((resolve20) => {
-    tail.on("exit", resolve20);
-  });
-  return c.text(output);
-});
-var logs_default = app7;
-
-// src/web/api/mind-skills.ts
-import { zValidator as zValidator2 } from "@hono/zod-validator";
-import { Hono as Hono8 } from "hono";
-import { z as z2 } from "zod";
-var app8 = new Hono8().get("/:name/skills", async (c) => {
-  const name = c.req.param("name");
-  const entry = findMind(name);
-  if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const dir = mindDir(name);
-  const skills = await listMindSkills(dir);
-  return c.json(skills);
-}).post(
-  "/:name/skills/install",
-  requireAdmin,
-  zValidator2("json", z2.object({ skillId: z2.string() })),
-  async (c) => {
-    const name = c.req.param("name");
-    const entry = findMind(name);
-    if (!entry) return c.json({ error: "Mind not found" }, 404);
-    const { skillId } = c.req.valid("json");
-    const dir = mindDir(name);
-    try {
-      await installSkill(name, dir, skillId);
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      return c.json({ error: msg }, 400);
-    }
-    return c.json({ ok: true });
-  }
-).post(
-  "/:name/skills/update",
-  requireAdmin,
-  zValidator2("json", z2.object({ skillId: z2.string() })),
-  async (c) => {
-    const name = c.req.param("name");
-    const entry = findMind(name);
-    if (!entry) return c.json({ error: "Mind not found" }, 404);
-    const { skillId } = c.req.valid("json");
-    const dir = mindDir(name);
-    try {
-      const result = await updateSkill(name, dir, skillId);
-      return c.json(result);
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      return c.json({ error: msg }, 400);
-    }
-  }
-).post(
-  "/:name/skills/publish",
-  requireAdmin,
-  zValidator2("json", z2.object({ skillId: z2.string() })),
-  async (c) => {
-    const name = c.req.param("name");
-    const entry = findMind(name);
-    if (!entry) return c.json({ error: "Mind not found" }, 404);
-    const { skillId } = c.req.valid("json");
-    const dir = mindDir(name);
-    try {
-      const skill = await publishSkill(name, dir, skillId);
-      return c.json(skill);
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      return c.json({ error: msg }, 400);
-    }
-  }
-).delete("/:name/skills/:skill", requireAdmin, async (c) => {
-  const name = c.req.param("name");
-  const skillName = c.req.param("skill");
-  const entry = findMind(name);
-  if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const dir = mindDir(name);
-  try {
-    await uninstallSkill(name, dir, skillName);
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : String(e);
-    return c.json({ error: msg }, 400);
-  }
-  return c.json({ ok: true });
-});
-var mind_skills_default = app8;
-
-// src/web/api/minds.ts
-import {
-  cpSync as cpSync2,
-  existsSync as existsSync10,
-  mkdirSync as mkdirSync7,
-  readdirSync as readdirSync4,
-  readFileSync as readFileSync9,
-  rmSync as rmSync2,
-  statSync as statSync2,
-  writeFileSync as writeFileSync8
-} from "fs";
-import { join as join2, resolve as resolve13 } from "path";
-import { zValidator as zValidator3 } from "@hono/zod-validator";
-import { and as and3, desc as desc2, eq as eq4, sql as sql2 } from "drizzle-orm";
-import { Hono as Hono9 } from "hono";
-import { z as z3 } from "zod";
-
-// src/lib/consolidate.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
-import { resolve as resolve10 } from "path";
-async function consolidateMemory(mindDir2) {
-  const soulPath = resolve10(mindDir2, "home/SOUL.md");
-  const memoryPath = resolve10(mindDir2, "home/MEMORY.md");
-  const memoryDir = resolve10(mindDir2, "home/memory");
-  const soul = readFileSync6(soulPath, "utf-8");
-  const logs = [];
-  try {
-    const files = readdirSync2(memoryDir).filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f)).sort();
-    for (const filename of files) {
-      const date = filename.replace(".md", "");
-      const content2 = readFileSync6(resolve10(memoryDir, filename), "utf-8").trim();
-      if (content2) {
-        logs.push(`### ${date}
+import { Hono as Hono6 } from "hono";
 
-${content2}`);
-      }
-    }
-  } catch {
-  }
-  if (logs.length === 0) {
-    console.log("No daily logs found.");
-    return;
+// src/lib/file-sharing.ts
+import { randomBytes } from "crypto";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readdirSync as readdirSync3, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync4 } from "fs";
+import { basename, join as join2, normalize, resolve as resolve8 } from "path";
+function validateFilePath(filePath) {
+  if (!filePath) return "File path is required";
+  const normalized = normalize(filePath);
+  if (normalized.startsWith("/") || normalized.startsWith("\\")) {
+    return "Absolute paths are not allowed";
   }
-  const apiKey = process.env.ANTHROPIC_API_KEY;
-  if (!apiKey) {
-    console.error("ANTHROPIC_API_KEY not set, skipping memory consolidation.");
-    return;
+  if (normalized.includes("..")) {
+    return "Path traversal (..) is not allowed";
   }
-  console.log("Consolidating memory from daily logs...");
-  const userMessage = [
-    "You have daily logs from a previous environment but no long-term memory file yet.",
-    "Please review the daily logs below and produce consolidated MEMORY.md content.",
-    "Keep it concise and organized by topic. Output ONLY the markdown content for MEMORY.md, nothing else.",
-    "",
-    "## Daily logs",
-    "",
-    logs.join("\n\n")
-  ].join("\n");
-  const res = await fetch("https://api.anthropic.com/v1/messages", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "x-api-key": apiKey,
-      "anthropic-version": "2023-06-01"
-    },
-    body: JSON.stringify({
-      model: "claude-sonnet-4-20250514",
-      max_tokens: 4096,
-      system: soul,
-      messages: [{ role: "user", content: userMessage }]
-    })
-  });
-  if (!res.ok) {
-    const body = await res.text();
-    console.error(`Anthropic API error (${res.status}): ${body}`);
-    return;
+  return null;
+}
+function configPath(dir) {
+  return resolve8(dir, "home", ".config", "file-sharing.json");
+}
+function readFileSharingConfig(dir) {
+  const p = configPath(dir);
+  if (!existsSync7(p)) return {};
+  try {
+    return JSON.parse(readFileSync5(p, "utf-8"));
+  } catch (err) {
+    console.warn(`[file-sharing] failed to parse config at ${p}:`, err);
+    return {};
   }
-  const data = await res.json();
-  const content = data.content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("").trim();
-  if (content) {
-    writeFileSync5(memoryPath, `${content}
+}
+function writeFileSharingConfig(dir, config) {
+  const p = configPath(dir);
+  mkdirSync4(resolve8(p, ".."), { recursive: true });
+  writeFileSync4(p, `${JSON.stringify(config, null, 2)}
 `);
-    console.log("MEMORY.md created successfully.");
-  } else {
-    console.warn("Warning: No content produced.");
-  }
 }
-
-// src/lib/conversations.ts
-import { randomUUID } from "crypto";
-import { and as and2, desc, eq as eq3, inArray, isNull, sql } from "drizzle-orm";
-
-// src/lib/conversation-events.ts
-var subscribers = /* @__PURE__ */ new Map();
-function subscribe(conversationId, callback) {
-  let set = subscribers.get(conversationId);
-  if (!set) {
-    set = /* @__PURE__ */ new Set();
-    subscribers.set(conversationId, set);
+function isTrustedSender(dir, sender) {
+  const config = readFileSharingConfig(dir);
+  return config.trustedSenders?.includes(sender) ?? false;
+}
+function addTrust(dir, sender) {
+  const config = readFileSharingConfig(dir);
+  const trusted = config.trustedSenders ?? [];
+  if (!trusted.includes(sender)) {
+    trusted.push(sender);
+  }
+  config.trustedSenders = trusted;
+  writeFileSharingConfig(dir, config);
+}
+function removeTrust(dir, sender) {
+  const config = readFileSharingConfig(dir);
+  const trusted = config.trustedSenders ?? [];
+  config.trustedSenders = trusted.filter((s) => s !== sender);
+  writeFileSharingConfig(dir, config);
+}
+function pendingDir(receiver) {
+  return resolve8(stateDir(receiver), "pending-files");
+}
+function validateId(id) {
+  if (!id || id.includes("/") || id.includes("\\") || id.includes("..")) {
+    throw new Error("Invalid pending file id");
   }
-  set.add(callback);
-  return () => {
-    set.delete(callback);
-    if (set.size === 0) subscribers.delete(conversationId);
+}
+function generateId(sender) {
+  const ts = Date.now();
+  const rand = randomBytes(2).toString("hex");
+  return `${sender}-${ts}-${rand}`;
+}
+function stageFile(receiver, sender, filename, content, originalPath) {
+  const err = validateFilePath(filename);
+  if (err) throw new Error(err);
+  if (sender.includes("/") || sender.includes("\\")) {
+    throw new Error("Invalid sender name");
+  }
+  const id = generateId(sender);
+  const dir = resolve8(pendingDir(receiver), id);
+  mkdirSync4(dir, { recursive: true });
+  const metadata = {
+    id,
+    sender,
+    filename: basename(filename),
+    originalPath,
+    size: content.length,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
+  writeFileSync4(resolve8(dir, "metadata.json"), `${JSON.stringify(metadata, null, 2)}
+`);
+  writeFileSync4(resolve8(dir, "data"), content);
+  return { id };
 }
-function publish(conversationId, event) {
-  const set = subscribers.get(conversationId);
-  if (!set) return;
-  for (const cb of set) {
+function listPending(receiver) {
+  const dir = pendingDir(receiver);
+  if (!existsSync7(dir)) return [];
+  const entries = readdirSync3(dir, { withFileTypes: true });
+  const result = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const metaPath = resolve8(dir, entry.name, "metadata.json");
+    if (!existsSync7(metaPath)) continue;
     try {
-      cb(event);
+      result.push(JSON.parse(readFileSync5(metaPath, "utf-8")));
     } catch (err) {
-      console.error("[conversation-events] subscriber threw:", err);
-      set.delete(cb);
-      if (set.size === 0) subscribers.delete(conversationId);
+      console.warn(`[file-sharing] skipping malformed pending entry ${entry.name}:`, err);
     }
   }
+  return result.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+function getPending(receiver, id) {
+  validateId(id);
+  const metaPath = resolve8(pendingDir(receiver), id, "metadata.json");
+  if (!existsSync7(metaPath)) return null;
+  try {
+    return JSON.parse(readFileSync5(metaPath, "utf-8"));
+  } catch (err) {
+    console.warn(`[file-sharing] failed to read pending metadata for ${id}:`, err);
+    return null;
+  }
+}
+function deliverFile(receiverDir, sender, filename, content, inboxPath) {
+  const err = validateFilePath(filename);
+  if (err) throw new Error(err);
+  const inbox = inboxPath ?? "inbox";
+  const inboxErr = validateFilePath(inbox);
+  if (inboxErr) throw new Error(`Invalid inboxPath: ${inboxErr}`);
+  if (sender.includes("/") || sender.includes("\\")) {
+    throw new Error("Invalid sender name");
+  }
+  const destDir = resolve8(receiverDir, "home", inbox, sender);
+  mkdirSync4(destDir, { recursive: true });
+  const destPath = resolve8(destDir, basename(filename));
+  writeFileSync4(destPath, content);
+  return join2(inbox, sender, basename(filename));
+}
+function acceptPending(receiver, id, receiverDir) {
+  const meta = getPending(receiver, id);
+  if (!meta) throw new Error(`Pending file not found: ${id}`);
+  const dataPath = resolve8(pendingDir(receiver), id, "data");
+  const content = readFileSync5(dataPath);
+  const config = readFileSharingConfig(receiverDir);
+  const inboxPath = config.inboxPath ?? "inbox";
+  const destPath = deliverFile(receiverDir, meta.sender, meta.filename, content, inboxPath);
+  rmSync(resolve8(pendingDir(receiver), id), { recursive: true });
+  return { sender: meta.sender, filename: meta.filename, destPath };
+}
+function rejectPending(receiver, id) {
+  const meta = getPending(receiver, id);
+  if (!meta) throw new Error(`Pending file not found: ${id}`);
+  rmSync(resolve8(pendingDir(receiver), id), { recursive: true });
+  return { sender: meta.sender, filename: meta.filename };
+}
+function formatFileSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
 
-// src/lib/conversations.ts
-async function createConversation(mindName, channel, opts) {
-  const db = await getDb();
-  const id = randomUUID();
-  const type = opts?.type ?? "dm";
-  const name = opts?.name ?? null;
-  await db.transaction(async (tx) => {
-    await tx.insert(conversations).values({
-      id,
-      mind_name: mindName,
-      channel,
-      type,
-      name,
-      user_id: opts?.userId ?? null,
-      title: opts?.title ?? null
+// src/web/api/file-sharing.ts
+async function notifyMind(port, message, channel, sender) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/message`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        content: [{ type: "text", text: message }],
+        channel,
+        sender
+      })
     });
-    if (opts?.participantIds && opts.participantIds.length > 0) {
-      await tx.insert(conversationParticipants).values(
-        opts.participantIds.map((uid, i) => ({
-          conversation_id: id,
-          user_id: uid,
-          role: i === 0 ? "owner" : "member"
-        }))
+    if (!res.ok) {
+      console.warn(`[file-sharing] notify mind on port ${port} failed: ${res.status}`);
+    }
+  } catch (err) {
+    console.warn(`[file-sharing] notify mind on port ${port} failed:`, err);
+  }
+}
+var app6 = new Hono6().post("/:name/files/send", async (c) => {
+  const senderName = c.req.param("name");
+  const senderEntry = findMind(senderName);
+  if (!senderEntry) return c.json({ error: "Sender mind not found" }, 404);
+  const body = await c.req.json();
+  if (!body.targetMind || !body.filePath) {
+    return c.json({ error: "targetMind and filePath are required" }, 400);
+  }
+  const receiverEntry = findMind(body.targetMind);
+  if (!receiverEntry) return c.json({ error: "Target mind not found" }, 404);
+  const pathErr = validateFilePath(body.filePath);
+  if (pathErr) return c.json({ error: pathErr }, 400);
+  const senderDir = mindDir(senderName);
+  const filePath = resolve9(senderDir, "home", body.filePath);
+  const MAX_FILE_SIZE = 50 * 1024 * 1024;
+  const stat3 = statSync2(filePath, { throwIfNoEntry: false });
+  if (!stat3) return c.json({ error: `File not found: ${body.filePath}` }, 404);
+  if (stat3.size > MAX_FILE_SIZE) {
+    return c.json(
+      {
+        error: `File too large (${formatFileSize(stat3.size)}, max ${formatFileSize(MAX_FILE_SIZE)})`
+      },
+      413
+    );
+  }
+  let content;
+  try {
+    content = readFileSync6(filePath);
+  } catch {
+    return c.json({ error: `File not found: ${body.filePath}` }, 404);
+  }
+  const receiverDir = mindDir(body.targetMind);
+  const filename = body.filePath;
+  const sizeStr = formatFileSize(content.length);
+  if (isTrustedSender(receiverDir, senderName)) {
+    const config = readFileSharingConfig(receiverDir);
+    const destPath = deliverFile(receiverDir, senderName, filename, content, config.inboxPath);
+    if (receiverEntry.running) {
+      await notifyMind(
+        receiverEntry.port,
+        `[file] ${senderName} sent ${filename} (${sizeStr}) \u2192 ${destPath}`,
+        "system:file-sharing",
+        senderName
       );
     }
+    return c.json({ status: "delivered", destPath }, 200);
+  }
+  const { id } = stageFile(body.targetMind, senderName, filename, content, body.filePath);
+  if (receiverEntry.running) {
+    await notifyMind(
+      receiverEntry.port,
+      `[file] ${senderName} wants to send ${filename} (${sizeStr}) \u2014 run: volute file accept ${id}`,
+      "system:file-sharing",
+      senderName
+    );
+  }
+  return c.json({ status: "pending", id }, 200);
+}).get("/:name/files/pending", (c) => {
+  const name = c.req.param("name");
+  if (!findMind(name)) return c.json({ error: "Mind not found" }, 404);
+  return c.json(listPending(name));
+}).post("/:name/files/accept", async (c) => {
+  const name = c.req.param("name");
+  const entry = findMind(name);
+  if (!entry) return c.json({ error: "Mind not found" }, 404);
+  const body = await c.req.json();
+  if (!body.id) return c.json({ error: "id is required" }, 400);
+  let result;
+  try {
+    result = acceptPending(name, body.id, mindDir(name));
+  } catch (err) {
+    const message = err.message;
+    if (message.includes("not found") || message.includes("Invalid pending")) {
+      return c.json({ error: message }, 404);
+    }
+    return c.json({ error: `Failed to accept file: ${message}` }, 500);
+  }
+  const senderEntry = findMind(result.sender);
+  if (senderEntry?.running) {
+    await notifyMind(
+      senderEntry.port,
+      `[file] ${name} accepted ${result.filename}`,
+      "system:file-sharing",
+      name
+    );
+  }
+  return c.json({ ok: true, destPath: result.destPath });
+}).post("/:name/files/reject", async (c) => {
+  const name = c.req.param("name");
+  if (!findMind(name)) return c.json({ error: "Mind not found" }, 404);
+  const body = await c.req.json();
+  if (!body.id) return c.json({ error: "id is required" }, 400);
+  let result;
+  try {
+    result = rejectPending(name, body.id);
+  } catch (err) {
+    const message = err.message;
+    if (message.includes("not found") || message.includes("Invalid pending")) {
+      return c.json({ error: message }, 404);
+    }
+    return c.json({ error: `Failed to reject file: ${message}` }, 500);
+  }
+  const senderEntry = findMind(result.sender);
+  if (senderEntry?.running) {
+    await notifyMind(
+      senderEntry.port,
+      `[file] ${name} rejected ${result.filename}`,
+      "system:file-sharing",
+      name
+    );
+  }
+  return c.json({ ok: true });
+}).post("/:name/files/trust", async (c) => {
+  const name = c.req.param("name");
+  if (!findMind(name)) return c.json({ error: "Mind not found" }, 404);
+  const body = await c.req.json();
+  if (!body.sender) return c.json({ error: "sender is required" }, 400);
+  addTrust(mindDir(name), body.sender);
+  return c.json({ ok: true });
+}).delete("/:name/files/trust/:sender", (c) => {
+  const name = c.req.param("name");
+  if (!findMind(name)) return c.json({ error: "Mind not found" }, 404);
+  const sender = c.req.param("sender");
+  removeTrust(mindDir(name), sender);
+  return c.json({ ok: true });
+});
+var file_sharing_default = app6;
+
+// src/web/api/files.ts
+import { existsSync as existsSync8 } from "fs";
+import { readdir, readFile } from "fs/promises";
+import { resolve as resolve10 } from "path";
+import { Hono as Hono7 } from "hono";
+var ALLOWED_FILES = /* @__PURE__ */ new Set(["SOUL.md", "MEMORY.md", "CLAUDE.md", "VOLUTE.md"]);
+var app7 = new Hono7().get("/:name/files", async (c) => {
+  const name = c.req.param("name");
+  const entry = findMind(name);
+  if (!entry) return c.json({ error: "Mind not found" }, 404);
+  const dir = mindDir(name);
+  const homeDir = resolve10(dir, "home");
+  if (!existsSync8(homeDir)) return c.json({ error: "Home directory missing" }, 404);
+  const allFiles = await readdir(homeDir);
+  const files = allFiles.filter((f) => f.endsWith(".md") && ALLOWED_FILES.has(f));
+  return c.json(files);
+}).get("/:name/files/:filename", async (c) => {
+  const name = c.req.param("name");
+  const filename = c.req.param("filename");
+  if (!ALLOWED_FILES.has(filename)) {
+    return c.json({ error: "File not allowed" }, 403);
+  }
+  const entry = findMind(name);
+  if (!entry) return c.json({ error: "Mind not found" }, 404);
+  const dir = mindDir(name);
+  const filePath = resolve10(dir, "home", filename);
+  if (!existsSync8(filePath)) {
+    return c.json({ error: "File not found" }, 404);
+  }
+  const content = await readFile(filePath, "utf-8");
+  return c.json({ filename, content });
+});
+var files_default = app7;
+
+// src/web/api/keys.ts
+import { Hono as Hono8 } from "hono";
+
+// src/lib/identity.ts
+import { createHash, generateKeyPairSync, sign, verify } from "crypto";
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { resolve as resolve11 } from "path";
+function generateIdentity(mindDir2) {
+  const identityDir = resolve11(mindDir2, ".mind/identity");
+  mkdirSync5(identityDir, { recursive: true });
+  const { publicKey, privateKey } = generateKeyPairSync("ed25519", {
+    publicKeyEncoding: { type: "spki", format: "pem" },
+    privateKeyEncoding: { type: "pkcs8", format: "pem" }
   });
-  return {
-    id,
-    mind_name: mindName,
-    channel,
-    type,
-    name,
-    user_id: opts?.userId ?? null,
-    title: opts?.title ?? null,
-    created_at: (/* @__PURE__ */ new Date()).toISOString(),
-    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  const privatePath = resolve11(identityDir, "private.pem");
+  const publicPath = resolve11(identityDir, "public.pem");
+  writeFileSync5(privatePath, privateKey, { mode: 384 });
+  writeFileSync5(publicPath, publicKey, { mode: 420 });
+  const config = readVoluteConfig(mindDir2) ?? {};
+  config.identity = {
+    privateKey: ".mind/identity/private.pem",
+    publicKey: ".mind/identity/public.pem"
   };
+  writeVoluteConfig(mindDir2, config);
+  return { publicKeyPem: publicKey, privateKeyPem: privateKey };
 }
-async function getConversation(id) {
-  const db = await getDb();
-  const row = await db.select().from(conversations).where(eq3(conversations.id, id)).get();
-  return row ?? null;
-}
-async function addParticipant(conversationId, userId, role = "member") {
-  const db = await getDb();
-  await db.insert(conversationParticipants).values({
-    conversation_id: conversationId,
-    user_id: userId,
-    role
-  });
-}
-async function removeParticipant(conversationId, userId) {
-  const db = await getDb();
-  await db.delete(conversationParticipants).where(
-    and2(
-      eq3(conversationParticipants.conversation_id, conversationId),
-      eq3(conversationParticipants.user_id, userId)
-    )
-  );
-}
-async function getParticipants(conversationId) {
-  const db = await getDb();
-  const rows = await db.select({
-    userId: conversationParticipants.user_id,
-    username: users.username,
-    userType: users.user_type,
-    role: conversationParticipants.role
-  }).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(
-      eq3(conversationParticipants.conversation_id, conversationId),
-      eq3(conversationParticipants.user_id, userId)
-    )
-  ).get();
-  return row != null;
+function getPrivateKey(mindDir2) {
+  const config = readVoluteConfig(mindDir2);
+  const relPath = config?.identity?.privateKey;
+  if (!relPath) return null;
+  const fullPath = resolve11(mindDir2, relPath);
+  if (!existsSync9(fullPath)) return null;
+  return readFileSync7(fullPath, "utf-8");
 }
-async function listConversationsForUser(userId) {
-  const db = await getDb();
-  const participantRows = await db.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(eq3(conversationParticipants.user_id, userId)).all();
-  if (participantRows.length === 0) return [];
-  const convIds = participantRows.map((r) => r.conversation_id);
-  return await db.select().from(conversations).where(inArray(conversations.id, convIds)).orderBy(desc(conversations.updated_at)).all();
+function getPublicKey(mindDir2) {
+  const config = readVoluteConfig(mindDir2);
+  const relPath = config?.identity?.publicKey;
+  if (!relPath) return null;
+  const fullPath = resolve11(mindDir2, relPath);
+  if (!existsSync9(fullPath)) return null;
+  return readFileSync7(fullPath, "utf-8");
 }
-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(eq3(conversations.id, conversationId), eq3(conversations.user_id, userId))).get();
-  return row != null;
+function getFingerprint(publicKeyPem) {
+  return createHash("sha256").update(publicKeyPem).digest("hex");
 }
-async function deleteConversationForUser(id, userId) {
-  if (!await isParticipantOrOwner(id, userId)) return false;
-  await deleteConversation(id);
-  return true;
+function signMessage(privateKeyPem, content, timestamp) {
+  const data = `${content}
+${timestamp}`;
+  const signature = sign(null, Buffer.from(data), privateKeyPem);
+  return signature.toString("base64");
 }
-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: 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(eq3(conversations.id, conversationId), isNull(conversations.title)));
+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;
   }
-  const msg = {
-    id: result.id,
-    conversation_id: conversationId,
-    role,
-    sender_name: senderName,
-    content,
-    created_at: result.created_at
-  };
-  publish(conversationId, {
-    type: "message",
-    id: msg.id,
-    role: msg.role,
-    senderName: msg.sender_name,
-    content: msg.content,
-    createdAt: msg.created_at
-  });
-  return msg;
 }
-async function getMessages(conversationId) {
-  const db = await getDb();
-  const rows = await db.select().from(messages).where(eq3(messages.conversation_id, conversationId)).orderBy(messages.created_at).all();
-  return rows.map((row) => {
-    let content;
+
+// src/web/api/keys.ts
+var app8 = new Hono8().get("/:fingerprint", (c) => {
+  const fingerprint = c.req.param("fingerprint");
+  for (const entry of readRegistry()) {
     try {
-      const parsed = JSON.parse(row.content);
-      content = Array.isArray(parsed) ? parsed : [{ type: "text", text: row.content }];
+      const pubKey = getPublicKey(mindDir(entry.name));
+      if (!pubKey) continue;
+      if (getFingerprint(pubKey) === fingerprint) {
+        return c.json({ publicKey: pubKey, mind: entry.name });
+      }
     } catch {
-      content = [{ type: "text", text: row.content }];
     }
-    return { ...row, content };
+  }
+  return c.json({ error: "Key not found" }, 404);
+});
+var keys_default = app8;
+
+// src/web/api/logs.ts
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync10 } from "fs";
+import { resolve as resolve12 } from "path";
+import { Hono as Hono9 } from "hono";
+import { streamSSE as streamSSE2 } from "hono/streaming";
+var app9 = new Hono9().get("/:name/logs", async (c) => {
+  const name = c.req.param("name");
+  const entry = findMind(name);
+  if (!entry) return c.json({ error: "Mind not found" }, 404);
+  const logFile = resolve12(stateDir(name), "logs", "mind.log");
+  if (!existsSync10(logFile)) {
+    return c.json({ error: "No log file found" }, 404);
+  }
+  return streamSSE2(c, async (stream) => {
+    const tail = spawn2("tail", ["-n", "200", "-f", logFile]);
+    const onData = (data) => {
+      const lines = data.toString().split("\n");
+      for (const line of lines) {
+        if (line) {
+          stream.writeSSE({ data: line }).catch(() => {
+          });
+        }
+      }
+    };
+    tail.stdout.on("data", onData);
+    stream.onAbort(() => {
+      tail.kill();
+    });
+    await new Promise((resolve23) => {
+      tail.on("exit", resolve23);
+      stream.onAbort(resolve23);
+    });
   });
-}
-async function listConversationsWithParticipants(userId) {
-  const convs = await listConversationsForUser(userId);
-  if (convs.length === 0) return [];
-  const db = await getDb();
-  const convIds = convs.map((c) => c.id);
-  const rows = await db.select({
-    conversationId: conversationParticipants.conversation_id,
-    userId: users.id,
-    username: users.username,
-    userType: users.user_type,
-    role: conversationParticipants.role
-  }).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);
-    if (!arr) {
-      arr = [];
-      byConv.set(r.conversationId, arr);
+}).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 = resolve12(stateDir(name), "logs", "mind.log");
+  if (!existsSync10(logFile)) {
+    return c.json({ error: "No log file found" }, 404);
+  }
+  const nParam = parseInt(c.req.query("n") ?? "50", 10);
+  const n = Number.isFinite(nParam) && nParam > 0 ? Math.min(nParam, 1e4) : 50;
+  const tail = spawn2("tail", ["-n", String(n), logFile]);
+  let output = "";
+  tail.stdout.on("data", (data) => {
+    output += data.toString();
+  });
+  await new Promise((resolve23) => {
+    tail.on("exit", resolve23);
+  });
+  return c.text(output);
+});
+var logs_default = app9;
+
+// src/web/api/mind-skills.ts
+import { zValidator as zValidator2 } from "@hono/zod-validator";
+import { Hono as Hono10 } from "hono";
+import { z as z2 } from "zod";
+var app10 = new Hono10().get("/:name/skills", async (c) => {
+  const name = c.req.param("name");
+  const entry = findMind(name);
+  if (!entry) return c.json({ error: "Mind not found" }, 404);
+  const dir = mindDir(name);
+  const skills = await listMindSkills(dir);
+  return c.json(skills);
+}).post(
+  "/:name/skills/install",
+  requireAdmin,
+  zValidator2("json", z2.object({ skillId: z2.string() })),
+  async (c) => {
+    const name = c.req.param("name");
+    const entry = findMind(name);
+    if (!entry) return c.json({ error: "Mind not found" }, 404);
+    const { skillId } = c.req.valid("json");
+    const dir = mindDir(name);
+    try {
+      await installSkill(name, dir, skillId);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      return c.json({ error: msg }, 400);
     }
-    arr.push({
-      userId: r.userId,
-      username: r.username,
-      userType: r.userType,
-      role: r.role
-    });
+    return c.json({ ok: true });
   }
-  const lastMsgIds = await db.select({
-    conversationId: messages.conversation_id,
-    maxId: sql`MAX(${messages.id})`
-  }).from(messages).where(inArray(messages.conversation_id, convIds)).groupBy(messages.conversation_id);
-  const byLastMsg = /* @__PURE__ */ new Map();
-  if (lastMsgIds.length > 0) {
-    const msgRows = await db.select().from(messages).where(
-      inArray(
-        messages.id,
-        lastMsgIds.map((r) => r.maxId)
-      )
-    );
-    for (const m of msgRows) {
-      let text = "";
-      try {
-        const parsed = JSON.parse(m.content);
-        const blocks = Array.isArray(parsed) ? parsed : [];
-        const textBlock = blocks.find((b) => b.type === "text");
-        if (textBlock && "text" in textBlock) text = textBlock.text;
-      } catch {
-        text = m.content;
+).post(
+  "/:name/skills/update",
+  requireAdmin,
+  zValidator2("json", z2.object({ skillId: z2.string() })),
+  async (c) => {
+    const name = c.req.param("name");
+    const entry = findMind(name);
+    if (!entry) return c.json({ error: "Mind not found" }, 404);
+    const { skillId } = c.req.valid("json");
+    const dir = mindDir(name);
+    try {
+      const result = await updateSkill(name, dir, skillId);
+      return c.json(result);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      return c.json({ error: msg }, 400);
+    }
+  }
+).post(
+  "/:name/skills/publish",
+  requireAdmin,
+  zValidator2("json", z2.object({ skillId: z2.string() })),
+  async (c) => {
+    const name = c.req.param("name");
+    const entry = findMind(name);
+    if (!entry) return c.json({ error: "Mind not found" }, 404);
+    const { skillId } = c.req.valid("json");
+    const dir = mindDir(name);
+    try {
+      const skill = await publishSkill(name, dir, skillId);
+      return c.json(skill);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      return c.json({ error: msg }, 400);
+    }
+  }
+).delete("/:name/skills/:skill", requireAdmin, async (c) => {
+  const name = c.req.param("name");
+  const skillName = c.req.param("skill");
+  const entry = findMind(name);
+  if (!entry) return c.json({ error: "Mind not found" }, 404);
+  const dir = mindDir(name);
+  try {
+    await uninstallSkill(name, dir, skillName);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return c.json({ error: msg }, 400);
+  }
+  return c.json({ ok: true });
+});
+var mind_skills_default = app10;
+
+// src/web/api/minds.ts
+import {
+  cpSync as cpSync2,
+  existsSync as existsSync12,
+  mkdirSync as mkdirSync8,
+  readdirSync as readdirSync6,
+  readFileSync as readFileSync11,
+  rmSync as rmSync3,
+  writeFileSync as writeFileSync9
+} from "fs";
+import { resolve as resolve16 } from "path";
+import { zValidator as zValidator3 } from "@hono/zod-validator";
+import { and as and3, desc as desc3, eq as eq4, sql as sql2 } from "drizzle-orm";
+import { Hono as Hono11 } from "hono";
+import { z as z3 } from "zod";
+
+// src/lib/consolidate.ts
+import { readdirSync as readdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
+import { resolve as resolve13 } from "path";
+async function consolidateMemory(mindDir2) {
+  const soulPath = resolve13(mindDir2, "home/SOUL.md");
+  const memoryPath = resolve13(mindDir2, "home/MEMORY.md");
+  const memoryDir = resolve13(mindDir2, "home/memory");
+  const soul = readFileSync8(soulPath, "utf-8");
+  const logs = [];
+  try {
+    const files = readdirSync4(memoryDir).filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f)).sort();
+    for (const filename of files) {
+      const date = filename.replace(".md", "");
+      const content2 = readFileSync8(resolve13(memoryDir, filename), "utf-8").trim();
+      if (content2) {
+        logs.push(`### ${date}
+
+${content2}`);
       }
-      byLastMsg.set(m.conversation_id, {
-        role: m.role,
-        senderName: m.sender_name,
-        text,
-        createdAt: m.created_at
-      });
     }
+  } catch {
   }
-  return convs.map((c) => ({
-    ...c,
-    participants: byConv.get(c.id) ?? [],
-    lastMessage: byLastMsg.get(c.id)
-  }));
-}
-async function findDMConversation(mindName, participantIds) {
-  const db = await getDb();
-  const mindConvs = await db.select({ id: conversations.id }).from(conversations).where(and2(eq3(conversations.mind_name, mindName), eq3(conversations.type, "dm"))).all();
-  for (const conv of mindConvs) {
-    const rows = await 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])) {
-      return conv.id;
-    }
+  if (logs.length === 0) {
+    console.log("No daily logs found.");
+    return;
   }
-  return null;
-}
-async function deleteConversation(id) {
-  const db = await getDb();
-  await db.delete(conversations).where(eq3(conversations.id, id));
-}
-async function createChannel(name, creatorId) {
-  const participantIds = creatorId ? [creatorId] : [];
-  return createConversation(null, "volute", {
-    type: "channel",
-    name,
-    title: name,
-    participantIds
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    console.error("ANTHROPIC_API_KEY not set, skipping memory consolidation.");
+    return;
+  }
+  console.log("Consolidating memory from daily logs...");
+  const userMessage = [
+    "You have daily logs from a previous environment but no long-term memory file yet.",
+    "Please review the daily logs below and produce consolidated MEMORY.md content.",
+    "Keep it concise and organized by topic. Output ONLY the markdown content for MEMORY.md, nothing else.",
+    "",
+    "## Daily logs",
+    "",
+    logs.join("\n\n")
+  ].join("\n");
+  const res = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01"
+    },
+    body: JSON.stringify({
+      model: "claude-sonnet-4-20250514",
+      max_tokens: 4096,
+      system: soul,
+      messages: [{ role: "user", content: userMessage }]
+    })
   });
-}
-async function getChannelByName(name) {
-  const db = await getDb();
-  const row = await db.select().from(conversations).where(and2(eq3(conversations.name, name), eq3(conversations.type, "channel"))).get();
-  return row ?? null;
-}
-async function listChannels() {
-  const db = await getDb();
-  return await db.select().from(conversations).where(eq3(conversations.type, "channel")).orderBy(conversations.name).all();
-}
-async function joinChannel(conversationId, userId) {
-  if (await isParticipant(conversationId, userId)) return;
-  await addParticipant(conversationId, userId);
-}
-async function leaveChannel(conversationId, userId) {
-  await removeParticipant(conversationId, userId);
+  if (!res.ok) {
+    const body = await res.text();
+    console.error(`Anthropic API error (${res.status}): ${body}`);
+    return;
+  }
+  const data = await res.json();
+  const content = data.content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("").trim();
+  if (content) {
+    writeFileSync6(memoryPath, `${content}
+`);
+    console.log("MEMORY.md created successfully.");
+  } else {
+    console.warn("Warning: No content produced.");
+  }
 }
 
 // src/lib/convert-session.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
 import { homedir } from "os";
-import { resolve as resolve11 } from "path";
+import { resolve as resolve14 } from "path";
 function convertSession(opts) {
-  const lines = readFileSync7(opts.sessionPath, "utf-8").trim().split("\n");
+  const lines = readFileSync9(opts.sessionPath, "utf-8").trim().split("\n");
   const sessionId = randomUUID2();
   const idMap = /* @__PURE__ */ new Map();
   const messages2 = [];
@@ -2510,10 +3125,10 @@ function convertSession(opts) {
     }
   }
   const projectId = opts.projectDir.replace(/\//g, "-");
-  const sdkDir = resolve11(homedir(), ".claude", "projects", projectId);
-  mkdirSync5(sdkDir, { recursive: true });
-  const sdkPath = resolve11(sdkDir, `${sessionId}.jsonl`);
-  writeFileSync6(sdkPath, `${sdkEvents.join("\n")}
+  const sdkDir = resolve14(homedir(), ".claude", "projects", projectId);
+  mkdirSync6(sdkDir, { recursive: true });
+  const sdkPath = resolve14(sdkDir, `${sessionId}.jsonl`);
+  writeFileSync7(sdkPath, `${sdkEvents.join("\n")}
 `);
   console.log(`Converted ${sdkEvents.length} messages \u2192 ${sdkPath}`);
   return sessionId;
@@ -2565,21 +3180,21 @@ function convertAssistantContent(content) {
 }
 
 // src/lib/mind-events.ts
-var subscribers2 = /* @__PURE__ */ new Map();
-function subscribe2(mind, callback) {
-  let set = subscribers2.get(mind);
+var subscribers = /* @__PURE__ */ new Map();
+function subscribe3(mind, callback) {
+  let set = subscribers.get(mind);
   if (!set) {
     set = /* @__PURE__ */ new Set();
-    subscribers2.set(mind, set);
+    subscribers.set(mind, set);
   }
   set.add(callback);
   return () => {
     set.delete(callback);
-    if (set.size === 0) subscribers2.delete(mind);
+    if (set.size === 0) subscribers.delete(mind);
   };
 }
-function publish2(mind, event) {
-  const set = subscribers2.get(mind);
+function publish3(mind, event) {
+  const set = subscribers.get(mind);
   if (!set) return;
   for (const cb of set) {
     try {
@@ -2587,7 +3202,7 @@ function publish2(mind, event) {
     } catch (err) {
       console.error("[mind-events] subscriber threw:", err);
       set.delete(cb);
-      if (set.size === 0) subscribers2.delete(mind);
+      if (set.size === 0) subscribers.delete(mind);
     }
   }
 }
@@ -2595,22 +3210,22 @@ function publish2(mind, event) {
 // src/lib/template.ts
 import {
   cpSync,
-  existsSync as existsSync9,
-  mkdirSync as mkdirSync6,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync8,
+  existsSync as existsSync11,
+  mkdirSync as mkdirSync7,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync10,
   renameSync as renameSync3,
-  rmSync,
-  statSync,
-  writeFileSync as writeFileSync7
+  rmSync as rmSync2,
+  statSync as statSync3,
+  writeFileSync as writeFileSync8
 } from "fs";
 import { tmpdir } from "os";
-import { dirname as dirname2, join, relative, resolve as resolve12 } from "path";
+import { dirname as dirname2, join as join3, relative, resolve as resolve15 } from "path";
 function findTemplatesRoot() {
   let dir = dirname2(new URL(import.meta.url).pathname);
   for (let i = 0; i < 5; i++) {
-    const candidate = resolve12(dir, "templates");
-    if (existsSync9(resolve12(candidate, "_base"))) return candidate;
+    const candidate = resolve15(dir, "templates");
+    if (existsSync11(resolve15(candidate, "_base"))) return candidate;
     dir = dirname2(dir);
   }
   console.error(
@@ -2620,72 +3235,72 @@ function findTemplatesRoot() {
   process.exit(1);
 }
 function composeTemplate(templatesRoot, templateName) {
-  const baseDir = resolve12(templatesRoot, "_base");
-  const templateDir = resolve12(templatesRoot, templateName);
-  if (!existsSync9(baseDir)) {
+  const baseDir = resolve15(templatesRoot, "_base");
+  const templateDir = resolve15(templatesRoot, templateName);
+  if (!existsSync11(baseDir)) {
     console.error("Base template not found:", baseDir);
     process.exit(1);
   }
-  if (!existsSync9(templateDir)) {
+  if (!existsSync11(templateDir)) {
     console.error(`Template not found: ${templateName}`);
     process.exit(1);
   }
-  const composedDir = resolve12(tmpdir(), `volute-template-${Date.now()}`);
-  mkdirSync6(composedDir, { recursive: true });
+  const composedDir = resolve15(tmpdir(), `volute-template-${Date.now()}`);
+  mkdirSync7(composedDir, { recursive: true });
   cpSync(baseDir, composedDir, { recursive: true });
   for (const file of listFiles(templateDir)) {
-    const src = resolve12(templateDir, file);
-    const dest = resolve12(composedDir, file);
-    mkdirSync6(dirname2(dest), { recursive: true });
+    const src = resolve15(templateDir, file);
+    const dest = resolve15(composedDir, file);
+    mkdirSync7(dirname2(dest), { recursive: true });
     cpSync(src, dest);
   }
-  const manifestPath = resolve12(composedDir, "volute-template.json");
-  if (!existsSync9(manifestPath)) {
-    rmSync(composedDir, { recursive: true, force: true });
+  const manifestPath = resolve15(composedDir, "volute-template.json");
+  if (!existsSync11(manifestPath)) {
+    rmSync2(composedDir, { recursive: true, force: true });
     console.error(`Template manifest not found: ${templateName}/volute-template.json`);
     process.exit(1);
   }
-  const manifest = JSON.parse(readFileSync8(manifestPath, "utf-8"));
-  rmSync(manifestPath);
+  const manifest = JSON.parse(readFileSync10(manifestPath, "utf-8"));
+  rmSync2(manifestPath);
   return { composedDir, manifest };
 }
 function copyTemplateToDir(composedDir, destDir, mindName, manifest) {
   cpSync(composedDir, destDir, { recursive: true });
   for (const [from, to] of Object.entries(manifest.rename)) {
-    const fromPath = resolve12(destDir, from);
-    if (existsSync9(fromPath)) {
-      renameSync3(fromPath, resolve12(destDir, to));
+    const fromPath = resolve15(destDir, from);
+    if (existsSync11(fromPath)) {
+      renameSync3(fromPath, resolve15(destDir, to));
     }
   }
   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));
+    const path = resolve15(destDir, file);
+    if (existsSync11(path)) {
+      const content = readFileSync10(path, "utf-8");
+      writeFileSync8(path, content.replaceAll("{{name}}", mindName));
     }
   }
 }
 function applyInitFiles(destDir) {
-  const initDir = resolve12(destDir, ".init");
-  if (!existsSync9(initDir)) return;
-  const homeDir = resolve12(destDir, "home");
+  const initDir = resolve15(destDir, ".init");
+  if (!existsSync11(initDir)) return;
+  const homeDir = resolve15(destDir, "home");
   for (const file of listFiles(initDir)) {
-    const src = resolve12(initDir, file);
-    const dest = resolve12(homeDir, file);
+    const src = resolve15(initDir, file);
+    const dest = resolve15(homeDir, file);
     const parent = dirname2(dest);
-    if (!existsSync9(parent)) {
-      mkdirSync6(parent, { recursive: true });
+    if (!existsSync11(parent)) {
+      mkdirSync7(parent, { recursive: true });
     }
     cpSync(src, dest);
   }
-  rmSync(initDir, { recursive: true, force: true });
+  rmSync2(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()) {
+    for (const entry of readdirSync5(current)) {
+      const full = join3(current, entry);
+      if (statSync3(full).isDirectory()) {
         if (entry === ".git") continue;
         walk(full);
       } else {
@@ -2729,6 +3344,12 @@ async function getMindStatus(name, port) {
   return { status, channels };
 }
 var TEMPLATE_BRANCH = "volute/template";
+async function configureGitIdentity(mindName, opts) {
+  const systemsConfig = readSystemsConfig();
+  const system = systemsConfig?.system ?? "local";
+  await gitExec(["config", "user.name", mindName], opts);
+  await gitExec(["config", "user.email", `${mindName}.${system}@volute.systems`], opts);
+}
 async function initTemplateBranch(projectRoot, composedDir, manifest, mindName, env) {
   const templateFiles = listFiles(composedDir).filter((f) => !f.startsWith(".init/") && !f.startsWith(".init\\")).map((f) => manifest.rename[f] ?? f);
   const opts = { cwd: projectRoot, mindName, env };
@@ -2740,7 +3361,7 @@ async function initTemplateBranch(projectRoot, composedDir, manifest, mindName,
   await gitExec(["commit", "-m", "initial commit"], opts);
 }
 async function updateTemplateBranch(projectRoot, template, mindName) {
-  const tempWorktree = resolve13(projectRoot, ".variants", "_template_update");
+  const tempWorktree = resolve16(projectRoot, ".variants", "_template_update");
   let branchExists = false;
   try {
     await gitExec(["rev-parse", "--verify", TEMPLATE_BRANCH], { cwd: projectRoot });
@@ -2751,8 +3372,8 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
     await gitExec(["worktree", "remove", "--force", tempWorktree], { cwd: projectRoot });
   } catch {
   }
-  if (existsSync10(tempWorktree)) {
-    rmSync2(tempWorktree, { recursive: true, force: true });
+  if (existsSync12(tempWorktree)) {
+    rmSync3(tempWorktree, { recursive: true, force: true });
   }
   const templatesRoot = findTemplatesRoot();
   const { composedDir, manifest } = composeTemplate(templatesRoot, template);
@@ -2772,9 +3393,9 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
       });
     }
     copyTemplateToDir(composedDir, tempWorktree, mindName, manifest);
-    const initDir = resolve13(tempWorktree, ".init");
-    if (existsSync10(initDir)) {
-      rmSync2(initDir, { recursive: true, force: true });
+    const initDir = resolve16(tempWorktree, ".init");
+    if (existsSync12(initDir)) {
+      rmSync3(initDir, { recursive: true, force: true });
     }
     await gitExec(["add", "-A"], { cwd: tempWorktree });
     try {
@@ -2787,10 +3408,10 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
       await gitExec(["worktree", "remove", "--force", tempWorktree], { cwd: projectRoot });
     } catch {
     }
-    if (existsSync10(tempWorktree)) {
-      rmSync2(tempWorktree, { recursive: true, force: true });
+    if (existsSync12(tempWorktree)) {
+      rmSync3(tempWorktree, { recursive: true, force: true });
     }
-    rmSync2(composedDir, { recursive: true, force: true });
+    rmSync3(composedDir, { recursive: true, force: true });
   }
 }
 async function mergeTemplateBranch(worktreeDir) {
@@ -2813,14 +3434,14 @@ 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: resolve13(cwd, "home") } });
+    await exec(cmd, args, { cwd, env: { ...process.env, HOME: resolve16(cwd, "home") } });
   } else {
     await exec("npm", ["install"], { cwd });
   }
 }
 async function importFromArchive(c, tempDir, nameOverride, manifest) {
-  const extractedMindDir = resolve13(tempDir, "mind");
-  if (!existsSync10(extractedMindDir)) {
+  const extractedMindDir = resolve16(tempDir, "mind");
+  if (!existsSync12(extractedMindDir)) {
     return c.json({ error: "Invalid archive: missing mind/ directory" }, 400);
   }
   if (!manifest?.includes || !manifest.name || !manifest.template) {
@@ -2832,34 +3453,34 @@ async function importFromArchive(c, tempDir, nameOverride, manifest) {
   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);
+  if (existsSync12(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"));
+    mkdirSync8(state, { recursive: true });
+    const channelsJson = resolve16(tempDir, "state/channels.json");
+    if (existsSync12(channelsJson)) {
+      cpSync2(channelsJson, resolve16(state, "channels.json"));
     }
-    const envJson = resolve13(tempDir, "state/env.json");
-    if (existsSync10(envJson)) {
-      cpSync2(envJson, resolve13(state, "env.json"));
+    const envJson = resolve16(tempDir, "state/env.json");
+    if (existsSync12(envJson)) {
+      cpSync2(envJson, resolve16(state, "env.json"));
     }
     const port = nextPort();
     addMind(name, port, void 0, manifest.template);
-    const homeDir = resolve13(dest, "home");
+    const homeDir = resolve16(dest, "home");
     ensureVoluteGroup();
     createMindUser(name, homeDir);
     chownMindDir(dest, name);
     await npmInstallAsMind(dest, name);
-    const historyJsonl = resolve13(tempDir, "history.jsonl");
-    if (existsSync10(historyJsonl)) {
+    const historyJsonl = resolve16(tempDir, "history.jsonl");
+    if (existsSync12(historyJsonl)) {
       try {
         const db = await getDb();
-        const lines = readFileSync9(historyJsonl, "utf-8").trim().split("\n");
+        const lines = readFileSync11(historyJsonl, "utf-8").trim().split("\n");
         let imported = 0;
         let failed = 0;
         for (const line of lines) {
@@ -2894,31 +3515,32 @@ async function importFromArchive(c, tempDir, nameOverride, manifest) {
         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));
+    const sessionsDir = resolve16(tempDir, "sessions");
+    if (existsSync12(sessionsDir)) {
+      const destSessions = resolve16(dest, ".mind/sessions");
+      mkdirSync8(destSessions, { recursive: true });
+      for (const file of readdirSync6(sessionsDir)) {
+        cpSync2(resolve16(sessionsDir, file), resolve16(destSessions, file));
       }
     }
-    if (!existsSync10(resolve13(dest, ".git"))) {
-      const env = isIsolationEnabled() ? { ...process.env, HOME: resolve13(dest, "home") } : void 0;
+    if (!existsSync12(resolve16(dest, ".git"))) {
+      const env = isIsolationEnabled() ? { ...process.env, HOME: resolve16(dest, "home") } : void 0;
       await gitExec(["init"], { cwd: dest, mindName: name, env });
+      await configureGitIdentity(name, { cwd: dest, mindName: name, env });
       await gitExec(["add", "-A"], { cwd: dest, mindName: name, env });
       await gitExec(["commit", "-m", "import from archive"], { cwd: dest, mindName: name, env });
     }
     chownMindDir(dest, name);
-    rmSync2(tempDir, { recursive: true, force: true });
+    rmSync3(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 });
+    if (existsSync12(dest)) rmSync3(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 });
+    rmSync3(tempDir, { recursive: true, force: true });
     return c.json({ error: err instanceof Error ? err.message : "Failed to import mind" }, 500);
   }
 }
@@ -2931,7 +3553,7 @@ var createMindSchema = z3.object({
   seedSoul: z3.string().optional(),
   skills: z3.array(z3.string()).optional()
 });
-var app9 = new Hono9().post("/", requireAdmin, zValidator3("json", createMindSchema), async (c) => {
+var app11 = new Hono11().post("/", requireAdmin, zValidator3("json", createMindSchema), async (c) => {
   const body = c.req.valid("json");
   const { name, template = "claude" } = body;
   const nameErr = validateMindName(name);
@@ -2939,7 +3561,7 @@ var app9 = new Hono9().post("/", requireAdmin, zValidator3("json", createMindSch
   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);
+  if (existsSync12(dest)) return c.json({ error: "Mind directory already exists" }, 409);
   const templatesRoot = findTemplatesRoot();
   const { composedDir, manifest } = composeTemplate(templatesRoot, template);
   try {
@@ -2947,21 +3569,21 @@ var app9 = new Hono9().post("/", requireAdmin, zValidator3("json", createMindSch
     applyInitFiles(dest);
     const { publicKeyPem } = generateIdentity(dest);
     if (body.model) {
-      const configPath = resolve13(dest, "home/.config/config.json");
-      const existing = existsSync10(configPath) ? JSON.parse(readFileSync9(configPath, "utf-8")) : {};
+      const configPath2 = resolve16(dest, "home/.config/config.json");
+      const existing = existsSync12(configPath2) ? JSON.parse(readFileSync11(configPath2, "utf-8")) : {};
       existing.model = body.model;
-      writeFileSync8(configPath, `${JSON.stringify(existing, null, 2)}
+      writeFileSync9(configPath2, `${JSON.stringify(existing, null, 2)}
 `);
     }
     const mindPrompts = await getMindPromptDefaults();
-    writeFileSync8(
-      resolve13(dest, "home/.config/prompts.json"),
+    writeFileSync9(
+      resolve16(dest, "home/.config/prompts.json"),
       `${JSON.stringify(mindPrompts, null, 2)}
 `
     );
     const port = nextPort();
     addMind(name, port, body.stage, template);
-    const homeDir = resolve13(dest, "home");
+    const homeDir = resolve16(dest, "home");
     ensureVoluteGroup();
     createMindUser(name, homeDir);
     chownMindDir(dest, name);
@@ -2970,10 +3592,11 @@ var app9 = new Hono9().post("/", requireAdmin, zValidator3("json", createMindSch
     try {
       const env = isIsolationEnabled() ? { ...process.env, HOME: homeDir } : void 0;
       await gitExec(["init"], { cwd: dest, mindName: name, env });
+      await configureGitIdentity(name, { cwd: dest, mindName: name, env });
       await initTemplateBranch(dest, composedDir, manifest, name, env);
     } catch (err) {
       logger_default.error(`git setup failed for ${name}`, logger_default.errorData(err));
-      rmSync2(resolve13(dest, ".git"), { recursive: true, force: true });
+      rmSync3(resolve16(dest, ".git"), { recursive: true, force: true });
       gitWarning = "Git setup failed \u2014 variants and upgrades won't be available until git is initialized.";
     }
     try {
@@ -2988,7 +3611,7 @@ The human who planted you described you as: "${body.description}"
 ` : "";
       const seedSoulRaw = body.seedSoul ?? await getPrompt("seed_soul", { name, description: descLine });
       const seedSoul = body.seedSoul ? substitute(seedSoulRaw, { name, description: descLine }) : seedSoulRaw;
-      writeFileSync8(resolve13(dest, "home/SOUL.md"), seedSoul);
+      writeFileSync9(resolve16(dest, "home/SOUL.md"), seedSoul);
     }
     const skillSet = body.skills ?? (body.stage === "seed" ? SEED_SKILLS : STANDARD_SKILLS);
     const skillWarnings = [];
@@ -3003,11 +3626,11 @@ The human who planted you described you as: "${body.description}"
     if (body.stage !== "seed") {
       const customSoul = await getPromptIfCustom("default_soul");
       if (customSoul) {
-        writeFileSync8(resolve13(dest, "home/SOUL.md"), customSoul.replace(/\{\{name\}\}/g, name));
+        writeFileSync9(resolve16(dest, "home/SOUL.md"), customSoul.replace(/\{\{name\}\}/g, name));
       }
       const customMemory = await getPromptIfCustom("default_memory");
       if (customMemory) {
-        writeFileSync8(resolve13(dest, "home/MEMORY.md"), customMemory);
+        writeFileSync9(resolve16(dest, "home/MEMORY.md"), customMemory);
       }
     }
     publishPublicKey(name, publicKeyPem).catch(
@@ -3023,14 +3646,14 @@ The human who planted you described you as: "${body.description}"
       ...skillWarnings.length > 0 && { skillWarnings }
     });
   } catch (err) {
-    if (existsSync10(dest)) rmSync2(dest, { recursive: true, force: true });
+    if (existsSync12(dest)) rmSync3(dest, { recursive: true, force: true });
     try {
       removeMind(name);
     } catch {
     }
     return c.json({ error: err instanceof Error ? err.message : "Failed to create mind" }, 500);
   } finally {
-    rmSync2(composedDir, { recursive: true, force: true });
+    rmSync3(composedDir, { recursive: true, force: true });
   }
 }).post("/import", requireAdmin, async (c) => {
   let body;
@@ -3043,13 +3666,13 @@ The human who planted you described you as: "${body.description}"
     return importFromArchive(c, body.archivePath, body.name, body.manifest);
   }
   const wsDir = body.workspacePath;
-  if (!wsDir || !existsSync10(resolve13(wsDir, "SOUL.md")) || !existsSync10(resolve13(wsDir, "IDENTITY.md"))) {
+  if (!wsDir || !existsSync12(resolve16(wsDir, "SOUL.md")) || !existsSync12(resolve16(wsDir, "IDENTITY.md"))) {
     return c.json({ error: "Invalid workspace: missing SOUL.md or IDENTITY.md" }, 400);
   }
-  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 soul = readFileSync11(resolve16(wsDir, "SOUL.md"), "utf-8");
+  const identity = readFileSync11(resolve16(wsDir, "IDENTITY.md"), "utf-8");
+  const userPath = resolve16(wsDir, "USER.md");
+  const user = existsSync12(userPath) ? readFileSync11(userPath, "utf-8") : "";
   const name = body.name ?? parseNameFromIdentity(identity) ?? "imported-mind";
   const template = body.template ?? "claude";
   const nameErr = validateMindName(name);
@@ -3069,39 +3692,39 @@ ${user.trimEnd()}
 ` : "";
   ensureVoluteHome();
   const dest = mindDir(name);
-  if (existsSync10(dest)) return c.json({ error: "Mind directory already exists" }, 409);
+  if (existsSync12(dest)) return c.json({ error: "Mind directory already exists" }, 409);
   const templatesRoot = findTemplatesRoot();
   const { composedDir, manifest } = composeTemplate(templatesRoot, template);
   try {
     copyTemplateToDir(composedDir, dest, name, manifest);
     applyInitFiles(dest);
     const { publicKeyPem: importPublicKey } = generateIdentity(dest);
-    writeFileSync8(resolve13(dest, "home/SOUL.md"), mergedSoul);
-    const wsMemoryPath = resolve13(wsDir, "MEMORY.md");
-    const hasMemory = existsSync10(wsMemoryPath);
+    writeFileSync9(resolve16(dest, "home/SOUL.md"), mergedSoul);
+    const wsMemoryPath = resolve16(wsDir, "MEMORY.md");
+    const hasMemory = existsSync12(wsMemoryPath);
     if (hasMemory) {
-      const existingMemory = readFileSync9(wsMemoryPath, "utf-8");
-      writeFileSync8(
-        resolve13(dest, "home/MEMORY.md"),
+      const existingMemory = readFileSync11(wsMemoryPath, "utf-8");
+      writeFileSync9(
+        resolve16(dest, "home/MEMORY.md"),
         `${existingMemory.trimEnd()}${mergedMemoryExtra}`
       );
     } else if (user) {
-      writeFileSync8(resolve13(dest, "home/MEMORY.md"), `${user.trimEnd()}
+      writeFileSync9(resolve16(dest, "home/MEMORY.md"), `${user.trimEnd()}
 `);
     }
-    const wsMemoryDir = resolve13(wsDir, "memory");
+    const wsMemoryDir = resolve16(wsDir, "memory");
     let dailyLogCount = 0;
-    if (existsSync10(wsMemoryDir)) {
-      const destMemoryDir = resolve13(dest, "home/memory");
-      const files = readdirSync4(wsMemoryDir).filter((f) => f.endsWith(".md"));
+    if (existsSync12(wsMemoryDir)) {
+      const destMemoryDir = resolve16(dest, "home/memory");
+      const files = readdirSync6(wsMemoryDir).filter((f) => f.endsWith(".md"));
       for (const file of files) {
-        cpSync2(resolve13(wsMemoryDir, file), resolve13(destMemoryDir, file));
+        cpSync2(resolve16(wsMemoryDir, file), resolve16(destMemoryDir, file));
       }
       dailyLogCount = files.length;
     }
     const port = nextPort();
     addMind(name, port, void 0, template);
-    const homeDir = resolve13(dest, "home");
+    const homeDir = resolve16(dest, "home");
     ensureVoluteGroup();
     createMindUser(name, homeDir);
     chownMindDir(dest, name);
@@ -3109,19 +3732,20 @@ ${user.trimEnd()}
     if (!hasMemory && dailyLogCount > 0) {
       await consolidateMemory(dest);
     }
-    const env = isIsolationEnabled() ? { ...process.env, HOME: resolve13(dest, "home") } : void 0;
+    const env = isIsolationEnabled() ? { ...process.env, HOME: resolve16(dest, "home") } : void 0;
     await gitExec(["init"], { cwd: dest, mindName: name, env });
+    await configureGitIdentity(name, { cwd: dest, mindName: name, env });
     await gitExec(["add", "-A"], { cwd: dest, mindName: name, env });
     await gitExec(["commit", "-m", "import from OpenClaw"], { cwd: dest, mindName: name, env });
-    const sessionFile = body.sessionPath ? resolve13(body.sessionPath) : findOpenClawSession(wsDir);
-    if (sessionFile && existsSync10(sessionFile)) {
+    const sessionFile = body.sessionPath ? resolve16(body.sessionPath) : findOpenClawSession(wsDir);
+    if (sessionFile && existsSync12(sessionFile)) {
       if (template === "pi") {
         importPiSession(sessionFile, dest);
       } else if (template === "claude") {
         const sessionId = convertSession({ sessionPath: sessionFile, projectDir: dest });
-        const mindRuntimeDir = resolve13(dest, ".mind");
-        mkdirSync7(mindRuntimeDir, { recursive: true });
-        writeFileSync8(resolve13(mindRuntimeDir, "session.json"), JSON.stringify({ sessionId }));
+        const mindRuntimeDir = resolve16(dest, ".mind");
+        mkdirSync8(mindRuntimeDir, { recursive: true });
+        writeFileSync9(resolve16(mindRuntimeDir, "session.json"), JSON.stringify({ sessionId }));
       }
     }
     importOpenClawConnectors(name, dest);
@@ -3136,14 +3760,14 @@ ${user.trimEnd()}
     );
     return c.json({ ok: true, name, port, message: `Imported mind: ${name} (port ${port})` });
   } catch (err) {
-    if (existsSync10(dest)) rmSync2(dest, { recursive: true, force: true });
+    if (existsSync12(dest)) rmSync3(dest, { recursive: true, force: true });
     try {
       removeMind(name);
     } catch {
     }
     return c.json({ error: err instanceof Error ? err.message : "Failed to import mind" }, 500);
   } finally {
-    rmSync2(composedDir, { recursive: true, force: true });
+    rmSync3(composedDir, { recursive: true, force: true });
   }
 }).get("/", async (c) => {
   const entries = readRegistry();
@@ -3160,7 +3784,7 @@ ${user.trimEnd()}
   const minds = await Promise.all(
     entries.map(async (entry) => {
       const { status, channels } = await getMindStatus(entry.name, entry.port);
-      const hasPages = existsSync10(resolve13(mindDir(entry.name), "home", "pages"));
+      const hasPages = existsSync12(resolve16(mindDir(entry.name), "home", "pages"));
       return {
         ...entry,
         status,
@@ -3171,58 +3795,15 @@ ${user.trimEnd()}
     })
   );
   return c.json(minds);
+}).get("/pages/sites", async (c) => {
+  return c.json(getCachedSites());
 }).get("/pages/recent", async (c) => {
-  const entries = readRegistry();
-  const pages = [];
-  for (const entry of entries) {
-    const pagesDir = resolve13(mindDir(entry.name), "home", "pages");
-    if (!existsSync10(pagesDir)) continue;
-    let items;
-    try {
-      items = readdirSync4(pagesDir);
-    } catch (err) {
-      logger_default.warn("Failed to read pages dir", { mind: entry.name, error: err.message });
-      continue;
-    }
-    for (const item of items) {
-      const fullPath = resolve13(pagesDir, item);
-      try {
-        const s = statSync2(fullPath);
-        if (s.isFile()) {
-          pages.push({
-            mind: entry.name,
-            file: item,
-            modified: s.mtime.toISOString(),
-            url: `/pages/${entry.name}/${item}`
-          });
-        } else if (s.isDirectory()) {
-          const indexPath = resolve13(fullPath, "index.html");
-          if (existsSync10(indexPath)) {
-            const indexStat = statSync2(indexPath);
-            pages.push({
-              mind: entry.name,
-              file: join2(item, "index.html"),
-              modified: indexStat.mtime.toISOString(),
-              url: `/pages/${entry.name}/${item}/`
-            });
-          }
-        }
-      } catch (err) {
-        logger_default.warn("Failed to stat page item", {
-          mind: entry.name,
-          item,
-          error: err.message
-        });
-      }
-    }
-  }
-  pages.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
-  return c.json(pages.slice(0, 10));
+  return c.json(getCachedRecentPages());
 }).get("/:name", async (c) => {
   const name = c.req.param("name");
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  if (!existsSync10(mindDir(name))) return c.json({ error: "Mind directory missing" }, 404);
+  if (!existsSync12(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();
@@ -3237,7 +3818,7 @@ ${user.trimEnd()}
       return { name: v.name, port: v.port, status: variantStatus };
     })
   );
-  const hasPages = existsSync10(resolve13(mindDir(name), "home", "pages"));
+  const hasPages = existsSync12(resolve16(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");
@@ -3249,7 +3830,7 @@ ${user.trimEnd()}
     if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
   } else {
     const dir = mindDir(baseName);
-    if (!existsSync10(dir)) return c.json({ error: "Mind directory missing" }, 404);
+    if (!existsSync12(dir)) return c.json({ error: "Mind directory missing" }, 404);
   }
   if (getMindManager().isRunning(name)) {
     return c.json({ error: "Mind already running" }, 409);
@@ -3270,7 +3851,7 @@ ${user.trimEnd()}
     if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
   } else {
     const dir = mindDir(baseName);
-    if (!existsSync10(dir)) return c.json({ error: "Mind directory missing" }, 404);
+    if (!existsSync12(dir)) return c.json({ error: "Mind directory missing" }, 404);
   }
   let context;
   const contentType = c.req.header("content-type");
@@ -3297,7 +3878,7 @@ ${user.trimEnd()}
       const variant = findVariant(baseName, mergeVariantName);
       if (variant) {
         const projectRoot = mindDir(baseName);
-        if (existsSync10(variant.path)) {
+        if (existsSync12(variant.path)) {
           const status = (await gitExec(["status", "--porcelain"], { cwd: variant.path })).trim();
           if (status) {
             try {
@@ -3325,7 +3906,7 @@ ${user.trimEnd()}
           }
         }
         await gitExec(["merge", variant.branch], { cwd: projectRoot });
-        if (existsSync10(variant.path)) {
+        if (existsSync12(variant.path)) {
           try {
             await gitExec(["worktree", "remove", "--force", variant.path], {
               cwd: projectRoot
@@ -3414,11 +3995,11 @@ ${user.trimEnd()}
   removeMind(name);
   await deleteMindUser2(name);
   const state = stateDir(name);
-  if (existsSync10(state)) {
-    rmSync2(state, { recursive: true, force: true });
+  if (existsSync12(state)) {
+    rmSync3(state, { recursive: true, force: true });
   }
-  if (force && existsSync10(dir)) {
-    rmSync2(dir, { recursive: true, force: true });
+  if (force && existsSync12(dir)) {
+    rmSync3(dir, { recursive: true, force: true });
     deleteMindUser(name);
   }
   return c.json({ ok: true });
@@ -3427,7 +4008,7 @@ ${user.trimEnd()}
   const entry = findMind(mindName);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const dir = mindDir(mindName);
-  if (!existsSync10(dir)) return c.json({ error: "Mind directory missing" }, 404);
+  if (!existsSync12(dir)) return c.json({ error: "Mind directory missing" }, 404);
   let body = {};
   try {
     body = await c.req.json();
@@ -3436,8 +4017,8 @@ ${user.trimEnd()}
   const template = body.template ?? entry.template ?? "claude";
   const UPGRADE_VARIANT = "upgrade";
   if (body.continue) {
-    const worktreeDir2 = resolve13(dir, ".variants", UPGRADE_VARIANT);
-    if (!existsSync10(worktreeDir2)) {
+    const worktreeDir2 = resolve16(dir, ".variants", UPGRADE_VARIANT);
+    if (!existsSync12(worktreeDir2)) {
       return c.json({ error: "No upgrade in progress" }, 400);
     }
     const status = await gitExec(["status", "--porcelain"], { cwd: worktreeDir2 });
@@ -3497,19 +4078,37 @@ ${user.trimEnd()}
       );
     }
   }
-  const worktreeDir = resolve13(dir, ".variants", UPGRADE_VARIANT);
-  if (existsSync10(worktreeDir)) {
+  const worktreeDir = resolve16(dir, ".variants", UPGRADE_VARIANT);
+  if (existsSync12(worktreeDir)) {
     return c.json(
       { error: "Upgrade variant already exists. Use continue or delete it first." },
       409
     );
   }
+  if (!existsSync12(resolve16(dir, ".git"))) {
+    try {
+      const env = isIsolationEnabled() ? { ...process.env, HOME: resolve16(dir, "home") } : void 0;
+      await gitExec(["init"], { cwd: dir, mindName, env });
+      await configureGitIdentity(mindName, { cwd: dir, mindName, env });
+      await gitExec(["add", "-A"], { cwd: dir, mindName, env });
+      await gitExec(["commit", "-m", "initial commit"], { cwd: dir, mindName, env });
+      chownMindDir(dir, mindName);
+    } catch (err) {
+      rmSync3(resolve16(dir, ".git"), { recursive: true, force: true });
+      return c.json(
+        {
+          error: `Git initialization failed: ${err instanceof Error ? err.message : String(err)}`
+        },
+        500
+      );
+    }
+  }
   await gitExec(["worktree", "prune"], { cwd: dir });
   try {
     await gitExec(["branch", "-D", UPGRADE_VARIANT], { cwd: dir });
   } catch {
   }
-  if (!existsSync10(resolve13(dir, "home", "shared"))) {
+  if (!existsSync12(resolve16(dir, "home", "shared"))) {
     try {
       await addSharedWorktree(mindName, dir);
     } catch (err) {
@@ -3520,9 +4119,9 @@ ${user.trimEnd()}
     }
   }
   await updateTemplateBranch(dir, template, mindName);
-  const parentDir = resolve13(dir, ".variants");
-  if (!existsSync10(parentDir)) {
-    mkdirSync7(parentDir, { recursive: true });
+  const parentDir = resolve16(dir, ".variants");
+  if (!existsSync12(parentDir)) {
+    mkdirSync8(parentDir, { recursive: true });
   }
   await gitExec(["worktree", "add", "-b", UPGRADE_VARIANT, worktreeDir], { cwd: dir });
   const hasConflicts = await mergeTemplateBranch(worktreeDir);
@@ -3704,7 +4303,79 @@ ${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) => {
+}).get("/:name/config", (c) => {
+  const name = c.req.param("name");
+  const entry = findMind(name);
+  if (!entry) return c.json({ error: "Mind not found" }, 404);
+  const dir = mindDir(name);
+  if (!existsSync12(dir)) return c.json({ error: "Mind directory missing" }, 404);
+  let config = readVoluteConfig(dir);
+  if (!config && entry.template === "pi") {
+    const piConfigPath = resolve16(dir, "home/.config/config.json");
+    if (existsSync12(piConfigPath)) {
+      try {
+        config = JSON.parse(readFileSync11(piConfigPath, "utf-8"));
+      } catch {
+      }
+    }
+  }
+  return c.json({
+    registry: {
+      name: entry.name,
+      port: entry.port,
+      created: entry.created,
+      stage: entry.stage,
+      template: entry.template
+    },
+    config: {
+      model: config?.model ?? null,
+      thinkingLevel: config?.thinkingLevel ?? null,
+      tokenBudget: config?.tokenBudget ?? null,
+      tokenBudgetPeriodMinutes: config?.tokenBudgetPeriodMinutes ?? null
+    }
+  });
+}).put(
+  "/:name/config",
+  requireAdmin,
+  zValidator3(
+    "json",
+    z3.object({
+      model: z3.string().optional(),
+      thinkingLevel: z3.enum(["off", "minimal", "low", "medium", "high", "xhigh"]).optional(),
+      tokenBudget: z3.number().int().positive().nullable().optional(),
+      tokenBudgetPeriodMinutes: z3.number().int().positive().nullable().optional()
+    })
+  ),
+  async (c) => {
+    const name = c.req.param("name");
+    const entry = findMind(name);
+    if (!entry) return c.json({ error: "Mind not found" }, 404);
+    const dir = mindDir(name);
+    if (!existsSync12(dir)) return c.json({ error: "Mind directory missing" }, 404);
+    const body = c.req.valid("json");
+    const existing = readVoluteConfig(dir) ?? {};
+    if (body.model !== void 0) existing.model = body.model;
+    if (body.thinkingLevel !== void 0) {
+      existing.thinkingLevel = body.thinkingLevel;
+    }
+    if (body.tokenBudget !== void 0) {
+      if (body.tokenBudget === null) {
+        delete existing.tokenBudget;
+      } else {
+        existing.tokenBudget = body.tokenBudget;
+      }
+    }
+    if (body.tokenBudgetPeriodMinutes !== void 0) {
+      if (body.tokenBudgetPeriodMinutes === null) {
+        delete existing.tokenBudgetPeriodMinutes;
+      } else {
+        existing.tokenBudgetPeriodMinutes = body.tokenBudgetPeriodMinutes;
+      }
+    }
+    writeVoluteConfig(dir, existing);
+    return c.json({ ok: true });
+  }
+).get("/:name/delivery/pending", async (c) => {
   const name = c.req.param("name");
   const [baseName] = name.split("@", 2);
   try {
@@ -3743,7 +4414,7 @@ ${user.trimEnd()}
   } catch (err) {
     logger_default.error(`failed to persist event for ${baseName}`, logger_default.errorData(err));
   }
-  publish2(baseName, {
+  publish3(baseName, {
     mind: baseName,
     type: body.type,
     session: body.session,
@@ -3752,15 +4423,17 @@ ${user.trimEnd()}
     content: body.content,
     metadata: body.metadata
   });
+  onMindEvent(baseName, body.type, body.channel);
   if ((body.type === "text" || body.type === "outbound") && body.channel) {
-    getTypingMap().delete(body.channel, baseName);
+    const map = getTypingMap();
+    const affected = map.deleteSender(baseName);
+    publishTypingForChannels(affected, map);
   }
   if (body.type === "done") {
-    if (body.channel) {
-      getTypingMap().delete(body.channel, baseName);
-    } else {
-      getTypingMap().deleteSender(baseName);
-    }
+    const map = getTypingMap();
+    const affected = map.deleteSender(baseName);
+    publishTypingForChannels(affected, map);
+    broadcast({ type: "mind_done", mind: baseName, summary: "Finished processing" });
     try {
       getDeliveryManager().sessionDone(baseName, body.session);
     } catch (err) {
@@ -3791,7 +4464,7 @@ ${user.trimEnd()}
 
 `));
       };
-      const unsubscribe = subscribe2(baseName, (event) => {
+      const unsubscribe = subscribe3(baseName, (event) => {
         if (typeFilter && !typeFilter.includes(event.type)) return;
         if (sessionFilter && event.session !== sessionFilter) return;
         if (channelFilter && event.channel !== channelFilter) return;
@@ -3873,15 +4546,15 @@ ${user.trimEnd()}
   if (!full) {
     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);
+  const rows = await db.select().from(mindHistory).where(and3(...conditions)).orderBy(desc3(mindHistory.created_at)).limit(limit).offset(offset);
   return c.json(rows);
 });
-var minds_default = app9;
+var minds_default = app11;
 
 // src/web/api/pages.ts
 import { readFile as readFile2, stat } from "fs/promises";
-import { extname, resolve as resolve14 } from "path";
-import { Hono as Hono10 } from "hono";
+import { extname, resolve as resolve17 } from "path";
+import { Hono as Hono12 } from "hono";
 var MIME_TYPES = {
   ".html": "text/html",
   ".js": "application/javascript",
@@ -3898,16 +4571,21 @@ var MIME_TYPES = {
   ".txt": "text/plain",
   ".xml": "application/xml"
 };
-var app10 = new Hono10().get("/:name/*", async (c) => {
+var app12 = new Hono12().get("/:name/*", async (c) => {
   const name = c.req.param("name");
-  if (!findMind(name)) return c.text("Not found", 404);
-  const pagesRoot = resolve14(mindDir(name), "home", "pages");
+  let pagesRoot;
+  if (name === "_system") {
+    pagesRoot = resolve17(voluteHome(), "shared", "pages");
+  } else {
+    if (!findMind(name)) return c.text("Not found", 404);
+    pagesRoot = resolve17(mindDir(name), "home", "pages");
+  }
   const wildcard = c.req.path.replace(`/pages/${name}`, "") || "/";
-  const requestedPath = resolve14(pagesRoot, wildcard.slice(1));
+  const requestedPath = resolve17(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 = resolve14(requestedPath, "index.html");
+    const indexPath = resolve17(requestedPath, "index.html");
     fileStat = await stat(indexPath).catch(() => null);
     if (fileStat?.isFile()) {
       const body = await readFile2(indexPath);
@@ -3923,14 +4601,14 @@ var app10 = new Hono10().get("/:name/*", async (c) => {
   }
   return c.text("Not found", 404);
 });
-var pages_default = app10;
+var pages_default = app12;
 
 // src/web/api/prompts.ts
 import { zValidator as zValidator4 } from "@hono/zod-validator";
 import { eq as eq5, sql as sql3 } from "drizzle-orm";
-import { Hono as Hono11 } from "hono";
+import { Hono as Hono13 } from "hono";
 import { z as z4 } from "zod";
-var app11 = new Hono11().get("/", async (c) => {
+var app13 = new Hono13().get("/", async (c) => {
   let rows;
   try {
     const db = await getDb();
@@ -3974,10 +4652,12 @@ var app11 = new Hono11().get("/", async (c) => {
   await db.delete(systemPrompts).where(eq5(systemPrompts.key, key));
   return c.json({ ok: true });
 });
-var prompts_default = app11;
+var prompts_default = app13;
 
 // src/web/api/schedules.ts
-import { Hono as Hono12 } from "hono";
+import { CronExpressionParser as CronExpressionParser2 } from "cron-parser";
+import { Hono as Hono14 } from "hono";
+var slog2 = logger_default.child("schedules");
 function readSchedules(name) {
   return readVoluteConfig(mindDir(name))?.schedules ?? [];
 }
@@ -3988,7 +4668,7 @@ function writeSchedules(name, schedules) {
   writeVoluteConfig(dir, config);
   getScheduler().loadSchedules(name);
 }
-var app12 = new Hono12().get("/:name/schedules", (c) => {
+var app14 = new Hono14().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));
@@ -3999,15 +4679,29 @@ var app12 = new Hono12().get("/:name/schedules", (c) => {
   if (entry.stage === "seed")
     return c.json({ error: "Seed minds cannot use schedules \u2014 sprout first" }, 403);
   const body = await c.req.json();
-  if (!body.cron || !body.message) {
-    return c.json({ error: "cron and message are required" }, 400);
+  if (!body.cron) {
+    return c.json({ error: "cron is required" }, 400);
+  }
+  if (!body.message && !body.script) {
+    return c.json({ error: "message or script is required" }, 400);
+  }
+  if (body.message && body.script) {
+    return c.json({ error: "message and script are mutually exclusive" }, 400);
+  }
+  try {
+    CronExpressionParser2.parse(body.cron);
+  } catch {
+    return c.json({ error: `Invalid cron expression: ${body.cron}` }, 400);
   }
   const schedules = readSchedules(name);
   const id = body.id || `schedule-${Date.now()}`;
   if (schedules.some((s) => s.id === id)) {
     return c.json({ error: `Schedule "${id}" already exists` }, 409);
   }
-  schedules.push({ id, cron: body.cron, message: body.message, enabled: body.enabled ?? true });
+  const schedule = { id, cron: body.cron, enabled: body.enabled ?? true };
+  if (body.message) schedule.message = body.message;
+  if (body.script) schedule.script = body.script;
+  schedules.push(schedule);
   writeSchedules(name, schedules);
   return c.json({ ok: true, id }, 201);
 }).put("/:name/schedules/:id", requireAdmin, async (c) => {
@@ -4018,8 +4712,25 @@ var app12 = new Hono12().get("/:name/schedules", (c) => {
   const idx = schedules.findIndex((s) => s.id === id);
   if (idx === -1) return c.json({ error: "Schedule not found" }, 404);
   const body = await c.req.json();
-  if (body.cron !== void 0) schedules[idx].cron = body.cron;
-  if (body.message !== void 0) schedules[idx].message = body.message;
+  if (body.message && body.script) {
+    return c.json({ error: "message and script are mutually exclusive" }, 400);
+  }
+  if (body.cron !== void 0) {
+    try {
+      CronExpressionParser2.parse(body.cron);
+    } catch {
+      return c.json({ error: `Invalid cron expression: ${body.cron}` }, 400);
+    }
+    schedules[idx].cron = body.cron;
+  }
+  if (body.message !== void 0) {
+    schedules[idx].message = body.message;
+    delete schedules[idx].script;
+  }
+  if (body.script !== void 0) {
+    schedules[idx].script = body.script;
+    delete schedules[idx].message;
+  }
   if (body.enabled !== void 0) schedules[idx].enabled = body.enabled;
   writeSchedules(name, schedules);
   return c.json({ ok: true });
@@ -4055,15 +4766,16 @@ var app12 = new Hono12().get("/:name/schedules", (c) => {
       return c.json({ error: `Mind responded with ${res.status}` }, 502);
     }
     return c.json({ ok: true });
-  } catch {
+  } catch (err) {
+    slog2.warn(`webhook delivery failed for ${name}`, logger_default.errorData(err));
     return c.json({ error: "Failed to reach mind" }, 502);
   }
 });
-var schedules_default = app12;
+var schedules_default = app14;
 
 // src/web/api/shared.ts
-import { Hono as Hono13 } from "hono";
-var app13 = new Hono13().post("/:name/shared/merge", requireAdmin, async (c) => {
+import { Hono as Hono15 } from "hono";
+var app15 = new Hono15().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);
@@ -4112,22 +4824,22 @@ var app13 = new Hono13().post("/:name/shared/merge", requireAdmin, async (c) =>
     return c.json({ error: err instanceof Error ? err.message : "Failed to get status" }, 500);
   }
 });
-var shared_default = app13;
+var shared_default = app15;
 
 // src/web/api/skills.ts
-import { existsSync as existsSync11, mkdtempSync, readdirSync as readdirSync5, rmSync as rmSync3 } from "fs";
+import { existsSync as existsSync13, mkdtempSync, readdirSync as readdirSync7, rmSync as rmSync4 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join3, resolve as resolve15 } from "path";
+import { join as join4, resolve as resolve18 } from "path";
 import AdmZip from "adm-zip";
-import { Hono as Hono14 } from "hono";
-var app14 = new Hono14().get("/", async (c) => {
+import { Hono as Hono16 } from "hono";
+var app16 = new Hono16().get("/", async (c) => {
   const skills = await listSharedSkills();
   return c.json(skills);
 }).get("/:id", async (c) => {
   const id = c.req.param("id");
   const skill = await getSharedSkill(id);
   if (!skill) return c.json({ error: "Skill not found" }, 404);
-  const dir = join3(sharedSkillsDir(), id);
+  const dir = join4(sharedSkillsDir(), id);
   const files = listFilesRecursive(dir);
   return c.json({ ...skill, files });
 }).post("/upload", requireAdmin, async (c) => {
@@ -4140,24 +4852,24 @@ var app14 = new Hono14().get("/", async (c) => {
     return c.json({ error: "Only .zip files are accepted" }, 400);
   }
   const buffer = Buffer.from(await file.arrayBuffer());
-  const tmpDir = mkdtempSync(join3(tmpdir2(), "volute-skill-upload-"));
+  const tmpDir = mkdtempSync(join4(tmpdir2(), "volute-skill-upload-"));
   try {
     const zip = new AdmZip(buffer);
     for (const entry of zip.getEntries()) {
-      const target = resolve15(tmpDir, entry.entryName);
+      const target = resolve18(tmpDir, entry.entryName);
       if (!target.startsWith(tmpDir)) {
         return c.json({ error: "Invalid zip: paths must not escape archive" }, 400);
       }
     }
     zip.extractAllTo(tmpDir, true);
     let skillDir = null;
-    if (existsSync11(join3(tmpDir, "SKILL.md"))) {
+    if (existsSync13(join4(tmpDir, "SKILL.md"))) {
       skillDir = tmpDir;
     } else {
-      const entries = readdirSync5(tmpDir, { withFileTypes: true }).filter((e) => e.isDirectory());
+      const entries = readdirSync7(tmpDir, { withFileTypes: true }).filter((e) => e.isDirectory());
       for (const entry of entries) {
-        if (existsSync11(join3(tmpDir, entry.name, "SKILL.md"))) {
-          skillDir = join3(tmpDir, entry.name);
+        if (existsSync13(join4(tmpDir, entry.name, "SKILL.md"))) {
+          skillDir = join4(tmpDir, entry.name);
           break;
         }
       }
@@ -4173,7 +4885,7 @@ var app14 = new Hono14().get("/", async (c) => {
     }
     throw e;
   } finally {
-    rmSync3(tmpDir, { recursive: true, force: true });
+    rmSync4(tmpDir, { recursive: true, force: true });
   }
 }).delete("/:id", requireAdmin, async (c) => {
   const id = c.req.param("id");
@@ -4185,12 +4897,12 @@ var app14 = new Hono14().get("/", async (c) => {
   }
   return c.json({ ok: true });
 });
-var skills_default = app14;
+var skills_default = app16;
 
 // src/web/api/system.ts
-import { Hono as Hono15 } from "hono";
-import { streamSSE as streamSSE2 } from "hono/streaming";
-var app15 = new Hono15().post("/restart", requireAdmin, (c) => {
+import { Hono as Hono17 } from "hono";
+import { streamSSE as streamSSE3 } from "hono/streaming";
+var app17 = new Hono17().post("/restart", requireAdmin, (c) => {
   setTimeout(() => process.exit(1), 200);
   return c.json({ ok: true });
 }).post("/stop", requireAdmin, (c) => {
@@ -4199,7 +4911,7 @@ var app15 = new Hono15().post("/restart", requireAdmin, (c) => {
 }).get("/logs", async (c) => {
   const user = c.get("user");
   if (user.role !== "admin") return c.json({ error: "Forbidden" }, 403);
-  return streamSSE2(c, async (stream) => {
+  return streamSSE3(c, async (stream) => {
     for (const entry of logBuffer.getEntries()) {
       await stream.writeSSE({ data: JSON.stringify(entry) });
     }
@@ -4207,10 +4919,10 @@ var app15 = new Hono15().post("/restart", requireAdmin, (c) => {
       stream.writeSSE({ data: JSON.stringify(entry) }).catch(() => {
       });
     });
-    await new Promise((resolve20) => {
+    await new Promise((resolve23) => {
       stream.onAbort(() => {
         unsubscribe();
-        resolve20();
+        resolve23();
       });
     });
   });
@@ -4218,18 +4930,18 @@ var app15 = new Hono15().post("/restart", requireAdmin, (c) => {
   const config = readSystemsConfig();
   return c.json({ system: config?.system ?? null });
 });
-var system_default = app15;
+var system_default = app17;
 
 // src/web/api/typing.ts
 import { zValidator as zValidator5 } from "@hono/zod-validator";
-import { Hono as Hono16 } from "hono";
+import { Hono as Hono18 } 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 app16 = new Hono16().post("/:name/typing", zValidator5("json", typingSchema), (c) => {
+var app18 = new Hono18().post("/:name/typing", zValidator5("json", typingSchema), (c) => {
   const { channel, sender, active } = c.req.valid("json");
   const map = getTypingMap();
   if (active) {
@@ -4237,6 +4949,11 @@ var app16 = new Hono16().post("/:name/typing", zValidator5("json", typingSchema)
   } else {
     map.delete(channel, sender);
   }
+  const volutePrefix = "volute:";
+  if (channel.startsWith(volutePrefix)) {
+    const conversationId = channel.slice(volutePrefix.length);
+    publish(conversationId, { type: "typing", senders: map.get(channel) });
+  }
   return c.json({ ok: true });
 }).get("/:name/typing", (c) => {
   const channel = c.req.query("channel");
@@ -4246,13 +4963,13 @@ var app16 = new Hono16().post("/:name/typing", zValidator5("json", typingSchema)
   const map = getTypingMap();
   return c.json({ typing: map.get(channel) });
 });
-var typing_default = app16;
+var typing_default = app18;
 
 // src/web/api/update.ts
 import { spawn as spawn3 } from "child_process";
-import { Hono as Hono17 } from "hono";
+import { Hono as Hono19 } from "hono";
 var bin;
-var app17 = new Hono17().get("/update", async (c) => {
+var app19 = new Hono19().get("/update", async (c) => {
   const result = await checkForUpdate();
   return c.json(result);
 }).post("/update", requireAdmin, async (c) => {
@@ -4267,19 +4984,19 @@ var app17 = new Hono17().get("/update", async (c) => {
   child.unref();
   return c.json({ ok: true, message: "Updating..." });
 });
-var update_default = app17;
+var update_default = app19;
 
 // src/web/api/variants.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
-import { resolve as resolve17 } from "path";
-import { Hono as Hono18 } from "hono";
+import { existsSync as existsSync14, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
+import { resolve as resolve20 } from "path";
+import { Hono as Hono20 } from "hono";
 
 // src/lib/spawn-server.ts
 import { spawn as spawn4 } from "child_process";
-import { closeSync, mkdirSync as mkdirSync8, openSync, readFileSync as readFileSync10 } from "fs";
-import { resolve as resolve16 } from "path";
+import { closeSync, mkdirSync as mkdirSync9, openSync, readFileSync as readFileSync12 } from "fs";
+import { resolve as resolve19 } from "path";
 function tsxBin(cwd) {
-  return resolve16(cwd, "node_modules", ".bin", "tsx");
+  return resolve19(cwd, "node_modules", ".bin", "tsx");
 }
 function spawnServer(cwd, port, options) {
   if (options?.detached) {
@@ -4292,31 +5009,31 @@ function spawnAttached(cwd, port) {
     cwd,
     stdio: ["ignore", "pipe", "pipe"]
   });
-  return new Promise((resolve20) => {
-    const timeout = setTimeout(() => resolve20(null), 3e4);
+  return new Promise((resolve23) => {
+    const timeout = setTimeout(() => resolve23(null), 3e4);
     function checkOutput(data) {
       const match = data.toString().match(/listening on :(\d+)/);
       if (match) {
         clearTimeout(timeout);
-        resolve20({ child, actualPort: parseInt(match[1], 10) });
+        resolve23({ child, actualPort: parseInt(match[1], 10) });
       }
     }
     child.stdout?.on("data", checkOutput);
     child.stderr?.on("data", checkOutput);
     child.on("error", () => {
       clearTimeout(timeout);
-      resolve20(null);
+      resolve23(null);
     });
     child.on("exit", () => {
       clearTimeout(timeout);
-      resolve20(null);
+      resolve23(null);
     });
   });
 }
 function spawnDetached(cwd, port, logDir) {
-  const logsDir = logDir ?? resolve16(cwd, ".mind", "logs");
-  mkdirSync8(logsDir, { recursive: true });
-  const logPath = resolve16(logsDir, "mind.log");
+  const logsDir = logDir ?? resolve19(cwd, ".mind", "logs");
+  mkdirSync9(logsDir, { recursive: true });
+  const logPath = resolve19(logsDir, "mind.log");
   const logFd = openSync(logPath, "a");
   const child = spawn4(tsxBin(cwd), ["src/server.ts", "--port", String(port)], {
     cwd,
@@ -4336,7 +5053,7 @@ function spawnDetached(cwd, port, logDir) {
     }
     const interval = setInterval(() => {
       try {
-        const content = readFileSync10(logPath, "utf-8");
+        const content = readFileSync12(logPath, "utf-8");
         const match = content.match(/listening on :(\d+)/);
         if (match) {
           finish({ child, actualPort: parseInt(match[1], 10) });
@@ -4388,7 +5105,7 @@ async function verify2(port) {
 }
 
 // src/web/api/variants.ts
-var app18 = new Hono18().get("/:name/variants", async (c) => {
+var app20 = new Hono20().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);
@@ -4418,11 +5135,11 @@ var app18 = new Hono18().get("/:name/variants", async (c) => {
   const err = validateBranchName(variantName);
   if (err) return c.json({ error: err }, 400);
   const projectRoot = mindDir(mindName);
-  const variantDir = resolve17(projectRoot, ".variants", variantName);
-  if (existsSync12(variantDir)) {
+  const variantDir = resolve20(projectRoot, ".variants", variantName);
+  if (existsSync14(variantDir)) {
     return c.json({ error: `Variant directory already exists: ${variantDir}` }, 409);
   }
-  mkdirSync9(resolve17(projectRoot, ".variants"), { recursive: true });
+  mkdirSync10(resolve20(projectRoot, ".variants"), { recursive: true });
   try {
     await gitExec(["worktree", "add", "-b", variantName, variantDir], { cwd: projectRoot });
   } catch (e) {
@@ -4435,7 +5152,7 @@ var app18 = new Hono18().get("/:name/variants", async (c) => {
       const [cmd, args] = wrapForIsolation("npm", ["install"], mindName);
       await exec(cmd, args, {
         cwd: variantDir,
-        env: { ...process.env, HOME: resolve17(variantDir, "home") }
+        env: { ...process.env, HOME: resolve20(variantDir, "home") }
       });
     } else {
       await exec("npm", ["install"], { cwd: variantDir });
@@ -4445,7 +5162,7 @@ var app18 = new Hono18().get("/:name/variants", async (c) => {
     return c.json({ error: `npm install failed: ${msg}` }, 500);
   }
   if (body.soul) {
-    writeFileSync9(resolve17(variantDir, "home/SOUL.md"), body.soul);
+    writeFileSync10(resolve20(variantDir, "home/SOUL.md"), body.soul);
   }
   const variantPort = body.port ?? nextPort();
   const variant = {
@@ -4483,7 +5200,7 @@ var app18 = new Hono18().get("/:name/variants", async (c) => {
   } catch {
   }
   const projectRoot = mindDir(mindName);
-  if (existsSync12(variant.path)) {
+  if (existsSync14(variant.path)) {
     const status = (await gitExec(["status", "--porcelain"], { cwd: variant.path })).trim();
     if (status) {
       try {
@@ -4540,7 +5257,7 @@ var app18 = new Hono18().get("/:name/variants", async (c) => {
   } catch (e) {
     return c.json({ error: "Merge failed. Resolve conflicts manually." }, 500);
   }
-  if (existsSync12(variant.path)) {
+  if (existsSync14(variant.path)) {
     try {
       await gitExec(["worktree", "remove", "--force", variant.path], { cwd: projectRoot });
     } catch {
@@ -4557,7 +5274,7 @@ var app18 = new Hono18().get("/:name/variants", async (c) => {
       const [cmd, args] = wrapForIsolation("npm", ["install"], mindName);
       await exec(cmd, args, {
         cwd: projectRoot,
-        env: { ...process.env, HOME: resolve17(projectRoot, "home") }
+        env: { ...process.env, HOME: resolve20(projectRoot, "home") }
       });
     } else {
       await exec("npm", ["install"], { cwd: projectRoot });
@@ -4600,7 +5317,7 @@ var app18 = new Hono18().get("/:name/variants", async (c) => {
     } catch {
     }
   }
-  if (existsSync12(variant.path)) {
+  if (existsSync14(variant.path)) {
     try {
       await gitExec(["worktree", "remove", "--force", variant.path], { cwd: projectRoot });
     } catch {
@@ -4614,11 +5331,11 @@ var app18 = new Hono18().get("/:name/variants", async (c) => {
   chownMindDir(projectRoot, mindName);
   return c.json({ ok: true });
 });
-var variants_default = app18;
+var variants_default = app20;
 
 // src/web/api/volute/channels.ts
 import { zValidator as zValidator6 } from "@hono/zod-validator";
-import { Hono as Hono19 } from "hono";
+import { Hono as Hono21 } 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")
@@ -4626,7 +5343,7 @@ var createSchema = z6.object({
 var inviteSchema = z6.object({
   username: z6.string().min(1)
 });
-var app19 = new Hono19().get("/", async (c) => {
+var app21 = new Hono21().get("/", async (c) => {
   const user = c.get("user");
   const channels = await listChannels();
   const results = await Promise.all(
@@ -4690,12 +5407,12 @@ var app19 = new Hono19().get("/", async (c) => {
   ]);
   return c.json({ ok: true });
 });
-var channels_default2 = app19;
+var channels_default2 = app21;
 
 // src/web/api/volute/chat.ts
 import { zValidator as zValidator7 } from "@hono/zod-validator";
-import { Hono as Hono20 } from "hono";
-import { streamSSE as streamSSE3 } from "hono/streaming";
+import { Hono as Hono22 } from "hono";
+import { streamSSE as streamSSE4 } from "hono/streaming";
 import { z as z7 } from "zod";
 async function fanOutToMinds(opts) {
   const participants = await getParticipants(opts.conversationId);
@@ -4703,7 +5420,7 @@ async function fanOutToMinds(opts) {
   const participantNames = participants.map((p) => p.username);
   const isDM = opts.isDM ?? participants.length === 2;
   const channelEntryType = opts.channelEntryType ?? (isDM ? "dm" : "group");
-  const { getMindManager: getMindManager2 } = await import("./mind-manager-RVCFROAY.js");
+  const { getMindManager: getMindManager2 } = await import("./mind-manager-3DMYKZPB.js");
   const manager = getMindManager2();
   const runningMinds = mindParticipants.map((ap) => {
     const key = opts.targetName ? opts.targetName(ap.username) : ap.username;
@@ -4735,7 +5452,7 @@ async function fanOutToMinds(opts) {
     const target = opts.targetName ? opts.targetName(mindName) : mindName;
     const channel = slugForMind(mindName);
     const typingMap = getTypingMap();
-    const currentlyTyping = typingMap.get(channel);
+    const currentlyTyping = typingMap.get(channel).filter((name) => participantNames.includes(name));
     deliverMessage(target, {
       content: opts.contentBlocks,
       channel,
@@ -4760,7 +5477,7 @@ var chatSchema = z7.object({
     })
   ).optional()
 });
-var app20 = new Hono20().post("/:name/chat", zValidator7("json", chatSchema), async (c) => {
+var app22 = new Hono22().post("/:name/chat", zValidator7("json", chatSchema), async (c) => {
   const name = c.req.param("name");
   const [baseName] = name.split("@", 2);
   const entry = findMind(baseName);
@@ -4832,7 +5549,7 @@ var app20 = new Hono20().post("/:name/chat", zValidator7("json", chatSchema), as
   if (user.id !== 0 && !await isParticipantOrOwner(conversationId, user.id)) {
     return c.json({ error: "Conversation not found" }, 404);
   }
-  return streamSSE3(c, async (stream) => {
+  return streamSSE4(c, async (stream) => {
     const unsubscribe = subscribe(conversationId, (event) => {
       stream.writeSSE({ data: JSON.stringify(event) }).catch((err) => {
         if (!stream.aborted) console.error("[chat] SSE write error:", err);
@@ -4843,11 +5560,11 @@ var app20 = new Hono20().post("/:name/chat", zValidator7("json", chatSchema), as
         if (!stream.aborted) console.error("[chat] SSE ping error:", err);
       });
     }, 15e3);
-    await new Promise((resolve20) => {
+    await new Promise((resolve23) => {
       stream.onAbort(() => {
         unsubscribe();
         clearInterval(keepAlive);
-        resolve20();
+        resolve23();
       });
     });
   });
@@ -4857,7 +5574,7 @@ var unifiedChatSchema = z7.object({
   conversationId: z7.string(),
   images: z7.array(z7.object({ media_type: z7.string(), data: z7.string() })).optional()
 });
-var unifiedChatApp = new Hono20().post(
+var unifiedChatApp = new Hono22().post(
   "/chat",
   zValidator7("json", unifiedChatSchema),
   async (c) => {
@@ -4893,18 +5610,18 @@ var unifiedChatApp = new Hono20().post(
     return c.json({ ok: true, conversationId: body.conversationId });
   }
 );
-var chat_default = app20;
+var chat_default = app22;
 
 // src/web/api/volute/conversations.ts
 import { zValidator as zValidator8 } from "@hono/zod-validator";
-import { Hono as Hono21 } from "hono";
+import { Hono as Hono23 } 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 app21 = new Hono21().get("/:name/conversations", async (c) => {
+var app23 = new Hono23().get("/:name/conversations", async (c) => {
   const name = c.req.param("name");
   const user = c.get("user");
   let lookupId = user.id;
@@ -4989,18 +5706,18 @@ var app21 = new Hono21().get("/:name/conversations", async (c) => {
   if (!deleted) return c.json({ error: "Conversation not found" }, 404);
   return c.json({ ok: true });
 });
-var conversations_default = app21;
+var conversations_default = app23;
 
 // src/web/api/volute/user-conversations.ts
 import { zValidator as zValidator9 } from "@hono/zod-validator";
-import { Hono as Hono22 } from "hono";
-import { streamSSE as streamSSE4 } from "hono/streaming";
+import { Hono as Hono24 } from "hono";
+import { streamSSE as streamSSE5 } 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 app22 = new Hono22().use("*", authMiddleware).get("/", async (c) => {
+var app24 = new Hono24().use("*", authMiddleware).get("/", async (c) => {
   const user = c.get("user");
   const convs = await listConversationsWithParticipants(user.id);
   return c.json(convs);
@@ -5048,7 +5765,7 @@ var app22 = new Hono22().use("*", authMiddleware).get("/", async (c) => {
   if (user.id !== 0 && !await isParticipantOrOwner(conversationId, user.id)) {
     return c.json({ error: "Conversation not found" }, 404);
   }
-  return streamSSE4(c, async (stream) => {
+  return streamSSE5(c, async (stream) => {
     const unsubscribe = subscribe(conversationId, (event) => {
       stream.writeSSE({ data: JSON.stringify(event) }).catch((err) => {
         if (!stream.aborted) console.error("[chat] SSE write error:", err);
@@ -5059,11 +5776,11 @@ var app22 = new Hono22().use("*", authMiddleware).get("/", async (c) => {
         if (!stream.aborted) console.error("[chat] SSE ping error:", err);
       });
     }, 15e3);
-    await new Promise((resolve20) => {
+    await new Promise((resolve23) => {
       stream.onAbort(() => {
         unsubscribe();
         clearInterval(keepAlive);
-        resolve20();
+        resolve23();
       });
     });
   });
@@ -5074,12 +5791,12 @@ var app22 = new Hono22().use("*", authMiddleware).get("/", async (c) => {
   if (!deleted) return c.json({ error: "Conversation not found" }, 404);
   return c.json({ ok: true });
 });
-var user_conversations_default = app22;
+var user_conversations_default = app24;
 
 // src/web/app.ts
 var httpLog = logger_default.child("http");
-var app23 = new Hono23();
-app23.onError((err, c) => {
+var app25 = new Hono25();
+app25.onError((err, c) => {
   if (err instanceof HTTPException) {
     return err.getResponse();
   }
@@ -5090,10 +5807,10 @@ app23.onError((err, c) => {
   });
   return c.json({ error: "Internal server error" }, 500);
 });
-app23.notFound((c) => {
+app25.notFound((c) => {
   return c.json({ error: "Not found" }, 404);
 });
-app23.use("*", async (c, next) => {
+app25.use("*", async (c, next) => {
   const start = Date.now();
   await next();
   const duration = Date.now() - start;
@@ -5104,7 +5821,7 @@ app23.use("*", async (c, next) => {
     httpLog.debug("request", data);
   }
 });
-app23.get("/api/health", (c) => {
+app25.get("/api/health", (c) => {
   let version = "unknown";
   let cached = null;
   try {
@@ -5119,18 +5836,19 @@ app23.get("/api/health", (c) => {
     ...cached?.updateAvailable ? { updateAvailable: true, latest: cached.latest } : {}
   });
 });
-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;
+app25.use("/api/*", bodyLimit({ maxSize: 10 * 1024 * 1024 }));
+app25.use("/api/*", csrf());
+app25.use("/api/activity/*", authMiddleware);
+app25.use("/api/minds/*", authMiddleware);
+app25.use("/api/conversations/*", authMiddleware);
+app25.use("/api/volute/*", authMiddleware);
+app25.use("/api/system/*", authMiddleware);
+app25.use("/api/env/*", authMiddleware);
+app25.use("/api/prompts/*", authMiddleware);
+app25.use("/api/skills/*", authMiddleware);
+app25.route("/pages", pages_default);
+var routes = app25.route("/api/activity", activity_default).route("/api/keys", keys_default).route("/api/auth", auth_default).route("/api/system", system_default).route("/api/system", update_default).route("/api/minds", minds_default).route("/api/minds", chat_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", file_sharing_default).route("/api/minds", files_default).route("/api/minds", channels_default).route("/api/minds", shared_default).route("/api/minds", env_default).route("/api/minds", mind_skills_default).route("/api/minds", conversations_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 = app25;
 
 // src/web/server.ts
 var MIME_TYPES2 = {
@@ -5149,8 +5867,8 @@ async function startServer({
   let assetsDir = "";
   let searchDir = dirname3(new URL(import.meta.url).pathname);
   for (let i = 0; i < 5; i++) {
-    const candidate = resolve18(searchDir, "dist", "web-assets");
-    if (existsSync13(candidate)) {
+    const candidate = resolve21(searchDir, "dist", "web-assets");
+    if (existsSync15(candidate)) {
       assetsDir = candidate;
       break;
     }
@@ -5160,7 +5878,7 @@ async function startServer({
     app_default.get("*", async (c) => {
       const urlPath = new URL(c.req.url).pathname;
       if (urlPath.startsWith("/api/")) return c.notFound();
-      const filePath = resolve18(assetsDir, urlPath.slice(1));
+      const filePath = resolve21(assetsDir, urlPath.slice(1));
       if (!filePath.startsWith(assetsDir)) return c.text("Forbidden", 403);
       const s = await stat2(filePath).catch(() => null);
       if (s?.isFile()) {
@@ -5169,7 +5887,7 @@ async function startServer({
         const body = await readFile3(filePath);
         return c.body(body, 200, { "Content-Type": mime });
       }
-      const indexPath = resolve18(assetsDir, "index.html");
+      const indexPath = resolve21(assetsDir, "index.html");
       const indexStat = await stat2(indexPath).catch(() => null);
       if (indexStat?.isFile()) {
         const body = await readFile3(indexPath, "utf-8");
@@ -5179,10 +5897,10 @@ async function startServer({
     });
   }
   const server = serve({ fetch: app_default.fetch, port, hostname });
-  await new Promise((resolve20, reject) => {
+  await new Promise((resolve23, reject) => {
     server.on("listening", () => {
       logger_default.info("Volute UI running", { hostname, port });
-      resolve20();
+      resolve23();
     });
     server.on("error", (err) => {
       reject(err);
@@ -5193,14 +5911,14 @@ async function startServer({
 
 // src/daemon.ts
 if (!process.env.VOLUTE_HOME) {
-  process.env.VOLUTE_HOME = resolve19(homedir2(), ".volute");
+  process.env.VOLUTE_HOME = resolve22(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(resolve19(home, "daemon.log"));
+    const rotatingLog = new RotatingLog(resolve22(home, "daemon.log"));
     logger_default.setOutput((line) => rotatingLog.write(`${line}
 `));
     const write = (...args) => rotatingLog.write(`${format(...args)}
@@ -5210,9 +5928,9 @@ async function startDaemon(opts) {
     console.warn = write;
     console.info = write;
   }
-  const DAEMON_PID_PATH = resolve19(home, "daemon.pid");
-  const DAEMON_JSON_PATH = resolve19(home, "daemon.json");
-  mkdirSync10(home, { recursive: true });
+  const DAEMON_PID_PATH = resolve22(home, "daemon.pid");
+  const DAEMON_JSON_PATH = resolve22(home, "daemon.json");
+  mkdirSync11(home, { recursive: true });
   migrateAgentsToMinds();
   try {
     await ensureSharedRepo();
@@ -5225,7 +5943,7 @@ async function startDaemon(opts) {
   } 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");
+  const token = process.env.VOLUTE_DAEMON_TOKEN || randomBytes2(32).toString("hex");
   process.env.VOLUTE_DAEMON_TOKEN = token;
   process.env.VOLUTE_DAEMON_PORT = String(port);
   process.env.VOLUTE_DAEMON_HOSTNAME = hostname;
@@ -5240,8 +5958,8 @@ async function startDaemon(opts) {
     }
     throw err;
   }
-  writeFileSync10(DAEMON_PID_PATH, myPid, { mode: 420 });
-  writeFileSync10(DAEMON_JSON_PATH, `${JSON.stringify({ port, hostname, token }, null, 2)}
+  writeFileSync11(DAEMON_PID_PATH, myPid, { mode: 420 });
+  writeFileSync11(DAEMON_JSON_PATH, `${JSON.stringify({ port, hostname, token }, null, 2)}
 `, {
     mode: 420
   });
@@ -5305,13 +6023,13 @@ async function startDaemon(opts) {
   logger_default.info(`running on ${hostname}:${port}, pid ${myPid}`);
   function cleanup() {
     try {
-      if (readFileSync11(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
+      if (readFileSync13(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
         unlinkSync2(DAEMON_PID_PATH);
       }
     } catch {
     }
     try {
-      const data = JSON.parse(readFileSync11(DAEMON_JSON_PATH, "utf-8"));
+      const data = JSON.parse(readFileSync13(DAEMON_JSON_PATH, "utf-8"));
       if (data.token === token) {
         unlinkSync2(DAEMON_JSON_PATH);
       }
@@ -5323,6 +6041,8 @@ async function startDaemon(opts) {
     if (shuttingDown) return;
     shuttingDown = true;
     logger_default.info("shutting down...");
+    stopAllWatchers();
+    stopAll();
     scheduler.stop();
     scheduler.saveState();
     mailPoller.stop();