volute 0.22.0 → 0.24.0

package/dist/daemon.js

@@ -8,10 +8,6 @@ import {
   sharedPull,
   sharedStatus
 } from "./chunk-PHHKNGA3.js";
-import {
-  fireWebhook,
-  initWebhook
-} from "./chunk-G5KRTU2F.js";
 import {
   applyInitFiles,
   composeTemplate,
@@ -21,29 +17,68 @@ import {
   listFiles
 } from "./chunk-AKPFNL7L.js";
 import {
+  addMessage,
+  approveUser,
+  changePassword,
+  countAdmins,
+  createChannel,
+  createConversation,
+  createUser,
+  deleteConversationForUser,
+  deleteMindUser as deleteMindUser2,
+  deleteUser,
   deliverMessage,
   extractTextContent,
+  findDMConversation,
+  fireWebhook,
   getCachedRecentPages,
   getCachedSites,
+  getChannelByName,
   getConnectorManager,
+  getConversation,
   getDeliveryManager,
   getMailPoller,
+  getMessages,
+  getMessagesPaginated,
+  getOrCreateMindUser,
+  getParticipants,
   getScheduler,
   getTokenBudget,
   getTypingMap,
+  getUnreadCounts,
+  getUser,
+  getUserByUsername,
   initConnectorManager,
   initDeliveryManager,
   initMailPoller,
   initScheduler,
   initSleepManager,
   initTokenBudget,
+  initWebhook,
+  isParticipant,
+  isParticipantOrOwner,
+  joinChannel,
+  leaveChannel,
+  listChannels,
+  listConversationsForUser,
+  listConversationsWithParticipants,
+  listPendingUsers,
+  listUsers,
+  listUsersByType,
+  markConversationRead,
   publish,
+  publish2,
   publishTypingForChannels,
+  recordInbound,
+  setUserRole,
   startMindFull,
   stopAllWatchers,
   stopMindFull,
-  subscribe as subscribe2
-} from "./chunk-OSFGKF2T.js";
+  subscribe as subscribe2,
+  subscribe2 as subscribe3,
+  updateUserProfile,
+  verifyUser
+} from "./chunk-OOW675I3.js";
 import {
   readSystemsConfig
 } from "./chunk-HFCBO2GL.js";
@@ -51,11 +86,11 @@ import {
   getActiveMinds,
   onMindEvent,
   stopAll
-} from "./chunk-HGCDWKSP.js";
+} from "./chunk-E7GOKNOT.js";
 import {
   broadcast,
   subscribe
-} from "./chunk-A4S7H6G6.js";
+} from "./chunk-BFK6SOEJ.js";
 import {
   PROMPT_DEFAULTS,
   PROMPT_KEYS,
@@ -66,13 +101,13 @@ import {
   getPromptIfCustom,
   initMindManager,
   substitute
-} from "./chunk-VNVCRVYI.js";
+} from "./chunk-NOBRGACV.js";
 import {
   findOpenClawSession,
   importOpenClawConnectors,
   importPiSession,
   parseNameFromIdentity
-} from "./chunk-RK627D57.js";
+} from "./chunk-4TJ72QQ3.js";
 import {
   readVoluteConfig,
   writeVoluteConfig
@@ -102,18 +137,15 @@ import {
   syncBuiltinSkills,
   uninstallSkill,
   updateSkill
-} from "./chunk-TFS25FIM.js";
+} from "./chunk-P3W36ZGD.js";
 import {
   activity,
-  conversationParticipants,
   conversations,
   getDb,
-  messages,
   mindHistory,
   sessions,
-  systemPrompts,
-  users
-} from "./chunk-SGPEZ32F.js";
+  systemPrompts
+} from "./chunk-33XAVCS4.js";
 import {
   logBuffer,
   logger_default
@@ -176,9 +208,9 @@ import {
 
 // src/daemon.ts
 import { randomBytes as randomBytes2 } from "crypto";
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync10, unlinkSync, writeFileSync as writeFileSync8 } from "fs";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync11, unlinkSync, writeFileSync as writeFileSync9 } from "fs";
 import { homedir as homedir2 } from "os";
-import { resolve as resolve17 } from "path";
+import { resolve as resolve18 } from "path";
 import { format } from "util";
 
 // src/lib/migrate-agents-to-minds.ts
@@ -356,145 +388,9 @@ function migrateMindState(name) {
 
 // src/web/middleware/auth.ts
 import { timingSafeEqual } from "crypto";
-import { eq as eq2, lt } from "drizzle-orm";
+import { eq, lt } from "drizzle-orm";
 import { getCookie } from "hono/cookie";
 import { createMiddleware } from "hono/factory";
-
-// src/lib/auth.ts
-import { compareSync, hashSync } from "bcryptjs";
-import { and, count, eq } from "drizzle-orm";
-async function createUser(username, password) {
-  const db = await getDb();
-  const hash = hashSync(password, 10);
-  const [{ value }] = await db.select({ value: count() }).from(users).where(eq(users.user_type, "brain"));
-  const role = value === 0 ? "admin" : "pending";
-  const [result] = await db.insert(users).values({ username, password_hash: hash, role }).returning({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  });
-  return result;
-}
-async function verifyUser(username, password) {
-  const db = await getDb();
-  const row = await db.select().from(users).where(eq(users.username, username)).get();
-  if (!row) return null;
-  if (row.user_type === "mind") return null;
-  if (!compareSync(password, row.password_hash)) return null;
-  const { password_hash: _, ...user } = row;
-  return user;
-}
-async function getUser(id) {
-  const db = await getDb();
-  const row = await db.select({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  }).from(users).where(eq(users.id, id)).get();
-  return row ?? null;
-}
-async function getUserByUsername(username) {
-  const db = await getDb();
-  const row = await db.select({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  }).from(users).where(eq(users.username, username)).get();
-  return row ?? null;
-}
-async function listUsers() {
-  const db = await getDb();
-  return db.select({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  }).from(users).orderBy(users.created_at).all();
-}
-async function listPendingUsers() {
-  const db = await getDb();
-  return db.select({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  }).from(users).where(eq(users.role, "pending")).orderBy(users.created_at).all();
-}
-async function listUsersByType(userType) {
-  const db = await getDb();
-  return db.select({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  }).from(users).where(eq(users.user_type, userType)).orderBy(users.created_at).all();
-}
-async function getOrCreateMindUser(mindName) {
-  const db = await getDb();
-  const existing = await db.select({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  }).from(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind"))).get();
-  if (existing) return existing;
-  try {
-    const [result] = await db.insert(users).values({
-      username: mindName,
-      password_hash: "!mind",
-      role: "mind",
-      user_type: "mind"
-    }).returning({
-      id: users.id,
-      username: users.username,
-      role: users.role,
-      user_type: users.user_type,
-      created_at: users.created_at
-    });
-    return result;
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
-      const retried = await db.select({
-        id: users.id,
-        username: users.username,
-        role: users.role,
-        user_type: users.user_type,
-        created_at: users.created_at
-      }).from(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind"))).get();
-      if (retried) return retried;
-    }
-    throw err;
-  }
-}
-async function deleteMindUser2(mindName) {
-  const db = await getDb();
-  await db.delete(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind")));
-}
-async function changePassword(userId, currentPassword, newPassword) {
-  const db = await getDb();
-  const row = await db.select().from(users).where(eq(users.id, userId)).get();
-  if (!row) return false;
-  if (!compareSync(currentPassword, row.password_hash)) return false;
-  const hash = hashSync(newPassword, 10);
-  await db.update(users).set({ password_hash: hash }).where(eq(users.id, userId));
-  return true;
-}
-async function approveUser(id) {
-  const db = await getDb();
-  await db.update(users).set({ role: "user" }).where(and(eq(users.id, id), eq(users.role, "pending")));
-}
-
-// src/web/middleware/auth.ts
 function isValidDaemonToken(token) {
   const expected = process.env.VOLUTE_DAEMON_TOKEN;
   if (!expected || token.length !== expected.length) return false;
@@ -503,6 +399,9 @@ function isValidDaemonToken(token) {
 var SESSION_MAX_AGE = 864e5;
 var SESSION_CACHE_TTL = 5 * 60 * 1e3;
 var sessionCache = /* @__PURE__ */ new Map();
+function invalidateSessionCache(sessionId) {
+  sessionCache.delete(sessionId);
+}
 async function createSession(userId) {
   const db = await getDb();
   const sessionId = crypto.randomUUID();
@@ -512,14 +411,14 @@ async function createSession(userId) {
 async function deleteSession(sessionId) {
   sessionCache.delete(sessionId);
   const db = await getDb();
-  await db.delete(sessions).where(eq2(sessions.id, sessionId));
+  await db.delete(sessions).where(eq(sessions.id, sessionId));
 }
 async function getSessionUserId(sessionId) {
   const db = await getDb();
-  const row = await db.select().from(sessions).where(eq2(sessions.id, sessionId)).get();
+  const row = await db.select().from(sessions).where(eq(sessions.id, sessionId)).get();
   if (!row) return void 0;
   if (Date.now() - row.createdAt > SESSION_MAX_AGE) {
-    await db.delete(sessions).where(eq2(sessions.id, sessionId));
+    await db.delete(sessions).where(eq(sessions.id, sessionId));
     return void 0;
   }
   return row.userId;
@@ -541,7 +440,15 @@ var authMiddleware = createMiddleware(async (c, next) => {
   if (authHeader?.startsWith("Bearer ")) {
     const token = authHeader.slice(7);
     if (token && isValidDaemonToken(token)) {
-      c.set("user", { id: 0, username: "cli", role: "admin", user_type: "brain" });
+      c.set("user", {
+        id: 0,
+        username: "cli",
+        role: "admin",
+        user_type: "brain",
+        display_name: null,
+        description: null,
+        avatar: null
+      });
       await next();
       return;
     }
@@ -572,9 +479,10 @@ var authMiddleware = createMiddleware(async (c, next) => {
 });
 
 // src/web/server.ts
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { readFile as readFile3, stat as stat3 } from "fs/promises";
-import { dirname, extname as extname3, resolve as resolve16 } from "path";
+import { createServer as createHttpsServer } from "https";
+import { dirname, extname as extname4, resolve as resolve17 } from "path";
 import { serve } from "@hono/node-server";
 
 // src/web/app.ts
@@ -584,294 +492,9 @@ import { csrf } from "hono/csrf";
 import { HTTPException } from "hono/http-exception";
 
 // src/web/api/activity.ts
-import { desc as desc2 } from "drizzle-orm";
+import { desc } from "drizzle-orm";
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
-
-// src/lib/events/conversations.ts
-import { randomUUID } from "crypto";
-import { and as and2, desc, eq as eq3, inArray, isNull, lt as lt2, 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"
-        }))
-      );
-    }
-  });
-  fireWebhook({
-    event: "conversation_created",
-    mind: mindName ?? "",
-    data: { id, mindName, channel, type, name, title: opts?.title ?? null }
-  });
-  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()
-  };
-}
-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
-  });
-  const conv = await db.select({ mind_name: conversations.mind_name }).from(conversations).where(eq3(conversations.id, conversationId)).get();
-  fireWebhook({
-    event: "message_created",
-    mind: conv?.mind_name ?? "",
-    data: {
-      conversationId,
-      messageId: result.id,
-      role,
-      senderName,
-      content: content.filter((b) => b.type !== "image"),
-      createdAt: result.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(parseMessageRow);
-}
-async function getMessagesPaginated(conversationId, opts) {
-  const db = await getDb();
-  const limit = Math.min(Math.max(opts?.limit ?? 50, 1), 100);
-  const conditions = [eq3(messages.conversation_id, conversationId)];
-  if (opts?.before != null) {
-    conditions.push(lt2(messages.id, opts.before));
-  }
-  const rows = await db.select().from(messages).where(and2(...conditions)).orderBy(desc(messages.id)).limit(limit + 1).all();
-  const hasMore = rows.length > limit;
-  const page = rows.slice(0, limit).reverse();
-  return {
-    messages: page.map(parseMessageRow),
-    hasMore
-  };
-}
-function parseMessageRow(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, role: row.role, 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) => {
@@ -880,7 +503,7 @@ var app = new Hono().get("/events", async (c) => {
       let recentActivity = [];
       try {
         const db = await getDb();
-        recentActivity = await db.select().from(activity).orderBy(desc2(activity.created_at)).limit(50);
+        recentActivity = await db.select().from(activity).orderBy(desc(activity.created_at)).limit(50);
         recentActivity = recentActivity.map((row) => ({
           ...row,
           metadata: row.metadata ? JSON.parse(row.metadata) : null
@@ -915,7 +538,7 @@ var app = new Hono().get("/events", async (c) => {
       });
       cleanups.push(unsubActivity);
       for (const conv of conversations2) {
-        const unsubConv = subscribe2(conv.id, (event) => {
+        const unsubConv = subscribe3(conv.id, (event) => {
           stream.writeSSE({
             data: JSON.stringify({ event: "conversation", conversationId: conv.id, ...event })
           }).catch((err) => {
@@ -930,8 +553,8 @@ var app = new Hono().get("/events", async (c) => {
         });
       }, 15e3);
       cleanups.push(() => clearInterval(keepAlive));
-      await new Promise((resolve18) => {
-        stream.onAbort(() => resolve18());
+      await new Promise((resolve19) => {
+        stream.onAbort(() => resolve19());
       });
     } finally {
       for (const cleanup of cleanups) {
@@ -946,6 +569,8 @@ var app = new Hono().get("/events", async (c) => {
 var activity_default = app;
 
 // src/web/api/auth.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { extname, resolve as resolve3 } from "path";
 import { zValidator } from "@hono/zod-validator";
 import { Hono as Hono2 } from "hono";
 import { deleteCookie, getCookie as getCookie2, setCookie } from "hono/cookie";
@@ -958,12 +583,71 @@ var changePasswordSchema = z.object({
   currentPassword: z.string().min(1),
   newPassword: z.string().min(1)
 });
+var profileSchema = z.object({
+  display_name: z.string().max(100).nullable().optional(),
+  description: z.string().max(500).nullable().optional()
+});
+var AVATAR_MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp"
+};
+var MAX_AVATAR_SIZE = 2 * 1024 * 1024;
+function avatarsDir() {
+  return resolve3(voluteHome(), "avatars");
+}
 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 });
+}).put("/profile", zValidator("json", profileSchema), async (c) => {
+  const user = c.get("user");
+  const body = c.req.valid("json");
+  await updateUserProfile(user.id, body);
+  const sessionId = getCookie2(c, "volute_session");
+  if (sessionId) invalidateSessionCache(sessionId);
+  return c.json({ ok: true });
+}).post("/avatar", async (c) => {
+  const user = c.get("user");
+  const body = await c.req.parseBody();
+  const file = body.file;
+  if (!(file instanceof File)) {
+    return c.json({ error: "No file uploaded" }, 400);
+  }
+  if (file.size > MAX_AVATAR_SIZE) {
+    return c.json({ error: "File too large (max 2MB)" }, 400);
+  }
+  const ext = extname(file.name).toLowerCase();
+  if (!AVATAR_MIME[ext]) {
+    return c.json({ error: "Invalid file type (png, jpg, gif, webp only)" }, 400);
+  }
+  const dir = avatarsDir();
+  mkdirSync2(dir, { recursive: true });
+  const filename = `avatar-${user.id}${ext}`;
+  const buffer2 = Buffer.from(await file.arrayBuffer());
+  writeFileSync2(resolve3(dir, filename), buffer2);
+  if (user.avatar && user.avatar !== filename) {
+    const oldPath = resolve3(dir, user.avatar);
+    rmSync(oldPath, { force: true });
+  }
+  await updateUserProfile(user.id, { avatar: filename });
+  const sessionId = getCookie2(c, "volute_session");
+  if (sessionId) invalidateSessionCache(sessionId);
+  return c.json({ ok: true, avatar: filename });
+}).delete("/avatar", async (c) => {
+  const user = c.get("user");
+  if (user.avatar) {
+    const path = resolve3(avatarsDir(), user.avatar);
+    rmSync(path, { force: true });
+  }
+  await updateUserProfile(user.id, { avatar: null });
+  const sessionId = getCookie2(c, "volute_session");
+  if (sessionId) invalidateSessionCache(sessionId);
+  return c.json({ ok: true });
 });
 var admin = new Hono2().use(authMiddleware).get("/users", async (c) => {
   const user = c.get("user");
@@ -985,8 +669,55 @@ 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 id = parseInt(c.req.param("id"), 10);
+  if (Number.isNaN(id)) return c.json({ error: "Invalid user ID" }, 400);
   await approveUser(id);
   return c.json({ ok: true });
+}).post(
+  "/users/:id/role",
+  zValidator("json", z.object({ role: z.enum(["admin", "user"]) })),
+  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);
+    if (Number.isNaN(id)) return c.json({ error: "Invalid user ID" }, 400);
+    const { role } = c.req.valid("json");
+    if (role !== "admin") {
+      const adminCount = await countAdmins();
+      if (adminCount <= 1) {
+        const target = await getUser(id);
+        if (target?.role === "admin") {
+          return c.json({ error: "Cannot remove the last admin" }, 400);
+        }
+      }
+    }
+    await setUserRole(id, role);
+    return c.json({ ok: true });
+  }
+).put("/users/:id/profile", zValidator("json", profileSchema), 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);
+  if (Number.isNaN(id)) return c.json({ error: "Invalid user ID" }, 400);
+  const body = c.req.valid("json");
+  await updateUserProfile(id, body);
+  return c.json({ ok: true });
+}).delete("/users/:id", 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);
+  if (Number.isNaN(id)) return c.json({ error: "Invalid user ID" }, 400);
+  if (id === user.id) return c.json({ error: "Cannot delete yourself" }, 400);
+  const target = await getUser(id);
+  if (!target) return c.json({ error: "User not found" }, 404);
+  if (target.role === "admin") {
+    const adminCount = await countAdmins();
+    if (adminCount <= 1) return c.json({ error: "Cannot delete the last admin" }, 400);
+  }
+  if (target.user_type === "mind") {
+    return c.json({ error: "Use the mind deletion API to delete minds" }, 400);
+  }
+  await deleteUser(id);
+  return c.json({ ok: true });
 });
 var app2 = new Hono2().post("/register", zValidator("json", credentialsSchema), async (c) => {
   const { username, password } = c.req.valid("json");
@@ -1023,7 +754,32 @@ var app2 = new Hono2().post("/register", zValidator("json", credentialsSchema),
   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 });
+  return c.json({
+    id: user.id,
+    username: user.username,
+    role: user.role,
+    display_name: user.display_name,
+    description: user.description,
+    avatar: user.avatar
+  });
+}).get("/avatars/:filename", async (c) => {
+  const filename = c.req.param("filename");
+  if (filename.includes("/") || filename.includes("\\") || filename.includes("..")) {
+    return c.json({ error: "Invalid filename" }, 400);
+  }
+  const dir = avatarsDir();
+  const filePath = resolve3(dir, filename);
+  if (!filePath.startsWith(`${dir}/`)) return c.json({ error: "Invalid path" }, 400);
+  if (!existsSync3(filePath)) return c.json({ error: "Not found" }, 404);
+  const ext = extname(filename).toLowerCase();
+  const mime = AVATAR_MIME[ext];
+  if (!mime) return c.json({ error: "Invalid file type" }, 400);
+  const data = readFileSync2(filePath);
+  return c.body(data, 200, {
+    "Content-Type": mime,
+    "Cache-Control": "public, max-age=3600",
+    "X-Content-Type-Options": "nosniff"
+  });
 }).route("/", admin).route("/", authenticated);
 var auth_default = app2;
 
@@ -1064,8 +820,8 @@ async function read(env, channelSlug, limit) {
   if (!res.ok) {
     throw new Error(`Discord API error: ${res.status} ${res.statusText}`);
   }
-  const messages2 = await res.json();
-  return messages2.reverse().map((m) => `${m.author.username}: ${m.content}`).join("\n");
+  const messages = await res.json();
+  return messages.reverse().map((m) => `${m.author.username}: ${m.content}`).join("\n");
 }
 async function send(env, channelSlug, message, images) {
   const token = requireToken(env);
@@ -1297,8 +1053,8 @@ async function listConversations2(env) {
   const userMap = /* @__PURE__ */ new Map();
   const imChannels = data.channels.filter((ch) => ch.is_im && ch.user);
   if (imChannels.length > 0) {
-    const users2 = await listUsers3(env);
-    for (const u of users2) {
+    const users = await listUsers3(env);
+    for (const u of users) {
       userMap.set(u.id, u.username);
     }
   }
@@ -1493,16 +1249,16 @@ __export(volute_exports, {
   read: () => read4,
   send: () => send4
 });
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { resolve as resolve3 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve4 } from "path";
 function getDaemonConfig() {
-  const configPath2 = resolve3(voluteHome(), "daemon.json");
-  if (!existsSync3(configPath2)) {
+  const configPath2 = resolve4(voluteHome(), "daemon.json");
+  if (!existsSync4(configPath2)) {
     throw new Error("Volute daemon is not running");
   }
   let config;
   try {
-    config = JSON.parse(readFileSync2(configPath2, "utf-8"));
+    config = JSON.parse(readFileSync3(configPath2, "utf-8"));
   } catch (err) {
     throw new Error(`Failed to parse ${configPath2}: ${err}`);
   }
@@ -1528,8 +1284,8 @@ async function read4(env, channelSlug, limit) {
   if (!res.ok) {
     throw new Error(`Failed to read conversation: ${res.status} ${res.statusText}`);
   }
-  const messages2 = await res.json();
-  return messages2.slice(-limit).map((m) => {
+  const messages = await res.json();
+  return messages.slice(-limit).map((m) => {
     const text = Array.isArray(m.content) ? m.content.filter((b) => b.type === "text").map((b) => b.text).join("") : m.content;
     return `${m.sender_name ?? m.role}: ${text}`;
   }).join("\n");
@@ -1756,8 +1512,8 @@ var app3 = new Hono3().post("/:name/channels/send", requireAdmin, async (c) => {
     return c.json({ error: `Platform ${platform} does not support listing users` }, 400);
   const env = buildEnv(name);
   try {
-    const users2 = await driver.listUsers(env);
-    return c.json(users2);
+    const users = await driver.listUsers(env);
+    return c.json(users);
   } catch (err) {
     return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
   }
@@ -1939,14 +1695,14 @@ var sharedEnvApp = new Hono5().get("/", (c) => {
 var env_default = app5;
 
 // src/web/api/file-sharing.ts
-import { readFileSync as readFileSync4, statSync } from "fs";
-import { resolve as resolve5 } from "path";
+import { readFileSync as readFileSync5, statSync } from "fs";
+import { resolve as resolve6 } from "path";
 import { Hono as Hono6 } from "hono";
 
 // src/lib/file-sharing.ts
 import { randomBytes } from "crypto";
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync2 } from "fs";
-import { basename, join, normalize, resolve as resolve4 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync4, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
+import { basename, join, normalize, resolve as resolve5 } from "path";
 function validateFilePath(filePath) {
   if (!filePath) return "File path is required";
   const normalized = normalize(filePath);
@@ -1959,13 +1715,13 @@ function validateFilePath(filePath) {
   return null;
 }
 function configPath(dir) {
-  return resolve4(dir, "home", ".config", "file-sharing.json");
+  return resolve5(dir, "home", ".config", "file-sharing.json");
 }
 function readFileSharingConfig(dir) {
   const p = configPath(dir);
-  if (!existsSync4(p)) return {};
+  if (!existsSync5(p)) return {};
   try {
-    return JSON.parse(readFileSync3(p, "utf-8"));
+    return JSON.parse(readFileSync4(p, "utf-8"));
   } catch (err) {
     console.warn(`[file-sharing] failed to parse config at ${p}:`, err);
     return {};
@@ -1973,8 +1729,8 @@ function readFileSharingConfig(dir) {
 }
 function writeFileSharingConfig(dir, config) {
   const p = configPath(dir);
-  mkdirSync2(resolve4(p, ".."), { recursive: true });
-  writeFileSync2(p, `${JSON.stringify(config, null, 2)}
+  mkdirSync3(resolve5(p, ".."), { recursive: true });
+  writeFileSync3(p, `${JSON.stringify(config, null, 2)}
 `);
 }
 function isTrustedSender(dir, sender) {
@@ -1997,7 +1753,7 @@ function removeTrust(dir, sender) {
   writeFileSharingConfig(dir, config);
 }
 function pendingDir(receiver) {
-  return resolve4(stateDir(receiver), "pending-files");
+  return resolve5(stateDir(receiver), "pending-files");
 }
 function validateId(id) {
   if (!id || id.includes("/") || id.includes("\\") || id.includes("..")) {
@@ -2016,8 +1772,8 @@ function stageFile(receiver, sender, filename, content, originalPath) {
     throw new Error("Invalid sender name");
   }
   const id = generateId(sender);
-  const dir = resolve4(pendingDir(receiver), id);
-  mkdirSync2(dir, { recursive: true });
+  const dir = resolve5(pendingDir(receiver), id);
+  mkdirSync3(dir, { recursive: true });
   const metadata = {
     id,
     sender,
@@ -2026,22 +1782,22 @@ function stageFile(receiver, sender, filename, content, originalPath) {
     size: content.length,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  writeFileSync2(resolve4(dir, "metadata.json"), `${JSON.stringify(metadata, null, 2)}
+  writeFileSync3(resolve5(dir, "metadata.json"), `${JSON.stringify(metadata, null, 2)}
 `);
-  writeFileSync2(resolve4(dir, "data"), content);
+  writeFileSync3(resolve5(dir, "data"), content);
   return { id };
 }
 function listPending(receiver) {
   const dir = pendingDir(receiver);
-  if (!existsSync4(dir)) return [];
+  if (!existsSync5(dir)) return [];
   const entries = readdirSync2(dir, { withFileTypes: true });
   const result = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const metaPath = resolve4(dir, entry.name, "metadata.json");
-    if (!existsSync4(metaPath)) continue;
+    const metaPath = resolve5(dir, entry.name, "metadata.json");
+    if (!existsSync5(metaPath)) continue;
     try {
-      result.push(JSON.parse(readFileSync3(metaPath, "utf-8")));
+      result.push(JSON.parse(readFileSync4(metaPath, "utf-8")));
     } catch (err) {
       console.warn(`[file-sharing] skipping malformed pending entry ${entry.name}:`, err);
     }
@@ -2050,10 +1806,10 @@ function listPending(receiver) {
 }
 function getPending(receiver, id) {
   validateId(id);
-  const metaPath = resolve4(pendingDir(receiver), id, "metadata.json");
-  if (!existsSync4(metaPath)) return null;
+  const metaPath = resolve5(pendingDir(receiver), id, "metadata.json");
+  if (!existsSync5(metaPath)) return null;
   try {
-    return JSON.parse(readFileSync3(metaPath, "utf-8"));
+    return JSON.parse(readFileSync4(metaPath, "utf-8"));
   } catch (err) {
     console.warn(`[file-sharing] failed to read pending metadata for ${id}:`, err);
     return null;
@@ -2068,27 +1824,27 @@ function deliverFile(receiverDir, sender, filename, content, inboxPath) {
   if (sender.includes("/") || sender.includes("\\")) {
     throw new Error("Invalid sender name");
   }
-  const destDir = resolve4(receiverDir, "home", inbox, sender);
-  mkdirSync2(destDir, { recursive: true });
-  const destPath = resolve4(destDir, basename(filename));
-  writeFileSync2(destPath, content);
+  const destDir = resolve5(receiverDir, "home", inbox, sender);
+  mkdirSync3(destDir, { recursive: true });
+  const destPath = resolve5(destDir, basename(filename));
+  writeFileSync3(destPath, content);
   return join(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 = resolve4(pendingDir(receiver), id, "data");
-  const content = readFileSync3(dataPath);
+  const dataPath = resolve5(pendingDir(receiver), id, "data");
+  const content = readFileSync4(dataPath);
   const config = readFileSharingConfig(receiverDir);
   const inboxPath = config.inboxPath ?? "inbox";
   const destPath = deliverFile(receiverDir, meta.sender, meta.filename, content, inboxPath);
-  rmSync(resolve4(pendingDir(receiver), id), { recursive: true });
+  rmSync2(resolve5(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(resolve4(pendingDir(receiver), id), { recursive: true });
+  rmSync2(resolve5(pendingDir(receiver), id), { recursive: true });
   return { sender: meta.sender, filename: meta.filename };
 }
 function formatFileSize(bytes) {
@@ -2129,7 +1885,7 @@ var app6 = new Hono6().post("/:name/files/send", async (c) => {
   const pathErr = validateFilePath(body.filePath);
   if (pathErr) return c.json({ error: pathErr }, 400);
   const senderDir = mindDir(senderName);
-  const filePath = resolve5(senderDir, "home", body.filePath);
+  const filePath = resolve6(senderDir, "home", body.filePath);
   const MAX_FILE_SIZE = 50 * 1024 * 1024;
   const stat4 = statSync(filePath, { throwIfNoEntry: false });
   if (!stat4) return c.json({ error: `File not found: ${body.filePath}` }, 404);
@@ -2143,7 +1899,7 @@ var app6 = new Hono6().post("/:name/files/send", async (c) => {
   }
   let content;
   try {
-    content = readFileSync4(filePath);
+    content = readFileSync5(filePath);
   } catch {
     return c.json({ error: `File not found: ${body.filePath}` }, 404);
   }
@@ -2245,19 +2001,19 @@ var app6 = new Hono6().post("/:name/files/send", async (c) => {
 var file_sharing_default = app6;
 
 // src/web/api/files.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { readdir, readFile, realpath, stat } from "fs/promises";
-import { extname, resolve as resolve6 } from "path";
+import { extname as extname2, resolve as resolve7 } from "path";
 import { Hono as Hono7 } from "hono";
 var ALLOWED_FILES = /* @__PURE__ */ new Set(["SOUL.md", "MEMORY.md", "CLAUDE.md", "VOLUTE.md"]);
-var AVATAR_MIME = {
+var AVATAR_MIME2 = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
   ".jpeg": "image/jpeg",
   ".gif": "image/gif",
   ".webp": "image/webp"
 };
-var MAX_AVATAR_SIZE = 2 * 1024 * 1024;
+var MAX_AVATAR_SIZE2 = 2 * 1024 * 1024;
 var app7 = new Hono7().get("/:name/avatar", async (c) => {
   const name = c.req.param("name");
   const entry = findMind(name);
@@ -2265,11 +2021,11 @@ var app7 = new Hono7().get("/:name/avatar", async (c) => {
   const dir = mindDir(name);
   const config = readVoluteConfig(dir);
   if (!config?.avatar) return c.json({ error: "No avatar configured" }, 404);
-  const ext = extname(config.avatar).toLowerCase();
-  const mime = AVATAR_MIME[ext];
+  const ext = extname2(config.avatar).toLowerCase();
+  const mime = AVATAR_MIME2[ext];
   if (!mime) return c.json({ error: "Invalid avatar extension" }, 400);
-  const homeDir = resolve6(dir, "home");
-  const avatarPath = resolve6(homeDir, config.avatar);
+  const homeDir = resolve7(dir, "home");
+  const avatarPath = resolve7(homeDir, config.avatar);
   if (!avatarPath.startsWith(`${homeDir}/`)) return c.json({ error: "Invalid avatar path" }, 400);
   let realAvatarPath;
   try {
@@ -2284,7 +2040,7 @@ var app7 = new Hono7().get("/:name/avatar", async (c) => {
   }
   try {
     const fileStat = await stat(realAvatarPath);
-    if (fileStat.size > MAX_AVATAR_SIZE) return c.json({ error: "Avatar file too large" }, 400);
+    if (fileStat.size > MAX_AVATAR_SIZE2) return c.json({ error: "Avatar file too large" }, 400);
     const body = await readFile(realAvatarPath);
     return c.body(body, 200, {
       "Content-Type": mime,
@@ -2298,8 +2054,8 @@ var app7 = new Hono7().get("/:name/avatar", async (c) => {
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const dir = mindDir(name);
-  const homeDir = resolve6(dir, "home");
-  if (!existsSync5(homeDir)) return c.json({ error: "Home directory missing" }, 404);
+  const homeDir = resolve7(dir, "home");
+  if (!existsSync6(homeDir)) return c.json({ error: "Home directory missing" }, 404);
   const allFiles = await readdir(homeDir);
   const files = allFiles.filter((f) => f.endsWith(".md") && ALLOWED_FILES.has(f));
   return c.json(files);
@@ -2312,8 +2068,8 @@ var app7 = new Hono7().get("/:name/avatar", async (c) => {
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const dir = mindDir(name);
-  const filePath = resolve6(dir, "home", filename);
-  if (!existsSync5(filePath)) {
+  const filePath = resolve7(dir, "home", filename);
+  if (!existsSync6(filePath)) {
     return c.json({ error: "File not found" }, 404);
   }
   const content = await readFile(filePath, "utf-8");
@@ -2326,19 +2082,19 @@ import { Hono as Hono8 } from "hono";
 
 // src/lib/identity.ts
 import { createHash, generateKeyPairSync, sign, verify } from "crypto";
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
-import { resolve as resolve7 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve8 } from "path";
 function generateIdentity(mindDir2) {
-  const identityDir = resolve7(mindDir2, ".mind/identity");
-  mkdirSync3(identityDir, { recursive: true });
+  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 = resolve7(identityDir, "private.pem");
-  const publicPath = resolve7(identityDir, "public.pem");
-  writeFileSync3(privatePath, privateKey, { mode: 384 });
-  writeFileSync3(publicPath, publicKey, { mode: 420 });
+  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",
@@ -2351,17 +2107,17 @@ function getPrivateKey(mindDir2) {
   const config = readVoluteConfig(mindDir2);
   const relPath = config?.identity?.privateKey;
   if (!relPath) return null;
-  const fullPath = resolve7(mindDir2, relPath);
-  if (!existsSync6(fullPath)) return null;
-  return readFileSync5(fullPath, "utf-8");
+  const fullPath = resolve8(mindDir2, relPath);
+  if (!existsSync7(fullPath)) return null;
+  return readFileSync6(fullPath, "utf-8");
 }
 function getPublicKey(mindDir2) {
   const config = readVoluteConfig(mindDir2);
   const relPath = config?.identity?.publicKey;
   if (!relPath) return null;
-  const fullPath = resolve7(mindDir2, relPath);
-  if (!existsSync6(fullPath)) return null;
-  return readFileSync5(fullPath, "utf-8");
+  const fullPath = resolve8(mindDir2, relPath);
+  if (!existsSync7(fullPath)) return null;
+  return readFileSync6(fullPath, "utf-8");
 }
 function getFingerprint(publicKeyPem) {
   return createHash("sha256").update(publicKeyPem).digest("hex");
@@ -2414,16 +2170,16 @@ var keys_default = app8;
 
 // src/web/api/logs.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync7 } from "fs";
-import { resolve as resolve8 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { resolve as resolve9 } 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 = resolve8(stateDir(name), "logs", "mind.log");
-  if (!existsSync7(logFile)) {
+  const logFile = resolve9(stateDir(name), "logs", "mind.log");
+  if (!existsSync8(logFile)) {
     return c.json({ error: "No log file found" }, 404);
   }
   return streamSSE2(c, async (stream) => {
@@ -2441,17 +2197,17 @@ var app9 = new Hono9().get("/:name/logs", async (c) => {
     stream.onAbort(() => {
       tail.kill();
     });
-    await new Promise((resolve18) => {
-      tail.on("exit", resolve18);
-      stream.onAbort(resolve18);
+    await new Promise((resolve19) => {
+      tail.on("exit", resolve19);
+      stream.onAbort(resolve19);
     });
   });
 }).get("/:name/logs/tail", async (c) => {
   const name = c.req.param("name");
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const logFile = resolve8(stateDir(name), "logs", "mind.log");
-  if (!existsSync7(logFile)) {
+  const logFile = resolve9(stateDir(name), "logs", "mind.log");
+  if (!existsSync8(logFile)) {
     return c.json({ error: "No log file found" }, 404);
   }
   const nParam = parseInt(c.req.query("n") ?? "50", 10);
@@ -2461,8 +2217,8 @@ var app9 = new Hono9().get("/:name/logs", async (c) => {
   tail.stdout.on("data", (data) => {
     output += data.toString();
   });
-  await new Promise((resolve18) => {
-    tail.on("exit", resolve18);
+  await new Promise((resolve19) => {
+    tail.on("exit", resolve19);
   });
   return c.text(output);
 });
@@ -2552,33 +2308,33 @@ var mind_skills_default = app10;
 // src/web/api/minds.ts
 import {
   cpSync,
-  existsSync as existsSync9,
-  mkdirSync as mkdirSync5,
+  existsSync as existsSync10,
+  mkdirSync as mkdirSync6,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync8,
-  rmSync as rmSync3,
-  writeFileSync as writeFileSync6
+  readFileSync as readFileSync9,
+  rmSync as rmSync4,
+  writeFileSync as writeFileSync7
 } from "fs";
-import { resolve as resolve11 } from "path";
+import { resolve as resolve12 } 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 { and, desc as desc2, eq as eq2, sql } from "drizzle-orm";
 import { Hono as Hono11 } from "hono";
 import { z as z3 } from "zod";
 
 // src/lib/consolidate.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
-import { resolve as resolve9 } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { resolve as resolve10 } from "path";
 async function consolidateMemory(mindDir2) {
-  const soulPath = resolve9(mindDir2, "home/SOUL.md");
-  const memoryPath = resolve9(mindDir2, "home/MEMORY.md");
-  const memoryDir = resolve9(mindDir2, "home/memory");
-  const soul = readFileSync6(soulPath, "utf-8");
+  const soulPath = resolve10(mindDir2, "home/SOUL.md");
+  const memoryPath = resolve10(mindDir2, "home/MEMORY.md");
+  const memoryDir = resolve10(mindDir2, "home/memory");
+  const soul = readFileSync7(soulPath, "utf-8");
   const logs = [];
   try {
     const files = readdirSync3(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(resolve9(memoryDir, filename), "utf-8").trim();
+      const content2 = readFileSync7(resolve10(memoryDir, filename), "utf-8").trim();
       if (content2) {
         logs.push(`### ${date}
 
@@ -2628,7 +2384,7 @@ ${content2}`);
   const data = await res.json();
   const content = data.content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("").trim();
   if (content) {
-    writeFileSync4(memoryPath, `${content}
+    writeFileSync5(memoryPath, `${content}
 `);
     console.log("MEMORY.md created successfully.");
   } else {
@@ -2637,28 +2393,28 @@ ${content2}`);
 }
 
 // src/lib/convert-session.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { randomUUID } from "crypto";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
 import { homedir } from "os";
-import { resolve as resolve10 } from "path";
+import { resolve as resolve11 } from "path";
 function convertSession(opts) {
-  const lines = readFileSync7(opts.sessionPath, "utf-8").trim().split("\n");
-  const sessionId = randomUUID2();
+  const lines = readFileSync8(opts.sessionPath, "utf-8").trim().split("\n");
+  const sessionId = randomUUID();
   const idMap = /* @__PURE__ */ new Map();
-  const messages2 = [];
+  const messages = [];
   for (const line of lines) {
     const event = JSON.parse(line);
     if (event.type === "message" && event.message) {
-      messages2.push(event);
+      messages.push(event);
     }
   }
   const sdkEvents = [];
   let lastSdkUuid = null;
-  for (let i = 0; i < messages2.length; i++) {
-    const event = messages2[i];
+  for (let i = 0; i < messages.length; i++) {
+    const event = messages[i];
     const msg = event.message;
     if (msg.role === "user") {
-      const uuid = randomUUID2();
+      const uuid = randomUUID();
       idMap.set(event.id, uuid);
       const parentUuid = event.parentId ? idMap.get(event.parentId) ?? null : null;
       const sdkEvent = {
@@ -2682,7 +2438,7 @@ function convertSession(opts) {
     } else if (msg.role === "assistant") {
       const content = convertAssistantContent(msg.content);
       if (content.length === 0) continue;
-      const uuid = randomUUID2();
+      const uuid = randomUUID();
       idMap.set(event.id, uuid);
       const parentUuid = event.parentId ? idMap.get(event.parentId) ?? null : null;
       const stopReason = mapStopReason(msg.stopReason);
@@ -2697,12 +2453,12 @@ function convertSession(opts) {
         isSidechain: false,
         userType: "external",
         type: "assistant",
-        requestId: `req_imported_${randomUUID2()}`,
+        requestId: `req_imported_${randomUUID()}`,
         message: {
           role: "assistant",
           content,
           type: "message",
-          id: `msg_imported_${randomUUID2()}`,
+          id: `msg_imported_${randomUUID()}`,
           model: mapModel(msg.model),
           stop_reason: stopReason,
           stop_sequence: null,
@@ -2716,8 +2472,8 @@ function convertSession(opts) {
       let lastToolResultId = event.id;
       let lastTimestamp = event.timestamp;
       let j = i;
-      while (j < messages2.length && messages2[j].message.role === "toolResult") {
-        const tr = messages2[j];
+      while (j < messages.length && messages[j].message.role === "toolResult") {
+        const tr = messages[j];
         const trMsg = tr.message;
         lastToolResultId = tr.id;
         lastTimestamp = tr.timestamp;
@@ -2730,7 +2486,7 @@ function convertSession(opts) {
         j++;
       }
       i = j - 1;
-      const uuid = randomUUID2();
+      const uuid = randomUUID();
       idMap.set(lastToolResultId, uuid);
       const parentUuid = event.parentId ? idMap.get(event.parentId) ?? null : lastSdkUuid;
       const sdkEvent = {
@@ -2756,10 +2512,10 @@ function convertSession(opts) {
     }
   }
   const projectId = opts.projectDir.replace(/\//g, "-");
-  const sdkDir = resolve10(homedir(), ".claude", "projects", projectId);
-  mkdirSync4(sdkDir, { recursive: true });
-  const sdkPath = resolve10(sdkDir, `${sessionId}.jsonl`);
-  writeFileSync5(sdkPath, `${sdkEvents.join("\n")}
+  const sdkDir = resolve11(homedir(), ".claude", "projects", projectId);
+  mkdirSync5(sdkDir, { recursive: true });
+  const sdkPath = resolve11(sdkDir, `${sessionId}.jsonl`);
+  writeFileSync6(sdkPath, `${sdkEvents.join("\n")}
 `);
   console.log(`Converted ${sdkEvents.length} messages \u2192 ${sdkPath}`);
   return sessionId;
@@ -2810,36 +2566,8 @@ function convertAssistantContent(content) {
   return result;
 }
 
-// src/lib/events/mind-events.ts
-var subscribers = /* @__PURE__ */ new Map();
-function subscribe3(mind, callback) {
-  let set = subscribers.get(mind);
-  if (!set) {
-    set = /* @__PURE__ */ new Set();
-    subscribers.set(mind, set);
-  }
-  set.add(callback);
-  return () => {
-    set.delete(callback);
-    if (set.size === 0) subscribers.delete(mind);
-  };
-}
-function publish2(mind, event) {
-  const set = subscribers.get(mind);
-  if (!set) return;
-  for (const cb of set) {
-    try {
-      cb(event);
-    } catch (err) {
-      console.error("[mind-events] subscriber threw:", err);
-      set.delete(cb);
-      if (set.size === 0) subscribers.delete(mind);
-    }
-  }
-}
-
 // src/lib/variant-cleanup.ts
-import { existsSync as existsSync8, rmSync as rmSync2 } from "fs";
+import { existsSync as existsSync9, rmSync as rmSync3 } from "fs";
 async function cleanupVariant(mindName, variantName, projectRoot, variantPath, opts) {
   if (opts?.stop) {
     try {
@@ -2847,11 +2575,11 @@ async function cleanupVariant(mindName, variantName, projectRoot, variantPath, o
     } catch {
     }
   }
-  if (existsSync8(variantPath)) {
+  if (existsSync9(variantPath)) {
     try {
       await gitExec(["worktree", "remove", "--force", variantPath], { cwd: projectRoot });
     } catch {
-      rmSync2(variantPath, { recursive: true, force: true });
+      rmSync3(variantPath, { recursive: true, force: true });
       try {
         await gitExec(["worktree", "prune"], { cwd: projectRoot });
       } catch {
@@ -2878,7 +2606,7 @@ async function getMindStatus(name, port) {
   const manager = getMindManager();
   let status = "stopped";
   try {
-    const { getSleepManagerIfReady } = await import("./sleep-manager-3RWUX2ZR.js");
+    const { getSleepManagerIfReady } = await import("./sleep-manager-XXSWQQLE.js");
     if (getSleepManagerIfReady()?.isSleeping(name)) {
       status = "sleeping";
     }
@@ -2936,7 +2664,7 @@ async function initTemplateBranch(projectRoot, composedDir, manifest, mindName,
   await gitExec(["commit", "-m", "initial commit"], opts);
 }
 async function updateTemplateBranch(projectRoot, template, mindName) {
-  const tempWorktree = resolve11(projectRoot, ".variants", "_template_update");
+  const tempWorktree = resolve12(projectRoot, ".variants", "_template_update");
   let branchExists = false;
   try {
     await gitExec(["rev-parse", "--verify", TEMPLATE_BRANCH], { cwd: projectRoot });
@@ -2947,8 +2675,8 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
     await gitExec(["worktree", "remove", "--force", tempWorktree], { cwd: projectRoot });
   } catch {
   }
-  if (existsSync9(tempWorktree)) {
-    rmSync3(tempWorktree, { recursive: true, force: true });
+  if (existsSync10(tempWorktree)) {
+    rmSync4(tempWorktree, { recursive: true, force: true });
   }
   const templatesRoot = findTemplatesRoot();
   const { composedDir, manifest } = composeTemplate(templatesRoot, template);
@@ -2968,9 +2696,9 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
       });
     }
     copyTemplateToDir(composedDir, tempWorktree, mindName, manifest);
-    const initDir = resolve11(tempWorktree, ".init");
-    if (existsSync9(initDir)) {
-      rmSync3(initDir, { recursive: true, force: true });
+    const initDir = resolve12(tempWorktree, ".init");
+    if (existsSync10(initDir)) {
+      rmSync4(initDir, { recursive: true, force: true });
     }
     await gitExec(["add", "-A"], { cwd: tempWorktree });
     try {
@@ -2983,10 +2711,10 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
       await gitExec(["worktree", "remove", "--force", tempWorktree], { cwd: projectRoot });
     } catch {
     }
-    if (existsSync9(tempWorktree)) {
-      rmSync3(tempWorktree, { recursive: true, force: true });
+    if (existsSync10(tempWorktree)) {
+      rmSync4(tempWorktree, { recursive: true, force: true });
     }
-    rmSync3(composedDir, { recursive: true, force: true });
+    rmSync4(composedDir, { recursive: true, force: true });
   }
 }
 async function mergeTemplateBranch(worktreeDir) {
@@ -3009,14 +2737,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: resolve11(cwd, "home") } });
+    await exec(cmd, args, { cwd, env: { ...process.env, HOME: resolve12(cwd, "home") } });
   } else {
     await exec("npm", ["install"], { cwd });
   }
 }
 async function importFromArchive(c, tempDir, nameOverride, manifest) {
-  const extractedMindDir = resolve11(tempDir, "mind");
-  if (!existsSync9(extractedMindDir)) {
+  const extractedMindDir = resolve12(tempDir, "mind");
+  if (!existsSync10(extractedMindDir)) {
     return c.json({ error: "Invalid archive: missing mind/ directory" }, 400);
   }
   if (!manifest?.includes || !manifest.name || !manifest.template) {
@@ -3034,21 +2762,21 @@ async function importFromFullArchive(c, tempDir, extractedMindDir, nameOverride,
   if (findMind(name)) return c.json({ error: `Mind already exists: ${name}` }, 409);
   ensureVoluteHome();
   const dest = mindDir(name);
-  if (existsSync9(dest)) return c.json({ error: "Mind directory already exists" }, 409);
+  if (existsSync10(dest)) return c.json({ error: "Mind directory already exists" }, 409);
   try {
     cpSync(extractedMindDir, dest, { recursive: true });
     if (!manifest.includes.identity) {
       generateIdentity(dest);
     }
     const state = stateDir(name);
-    mkdirSync5(state, { recursive: true });
-    const channelsJson = resolve11(tempDir, "state/channels.json");
-    if (existsSync9(channelsJson)) {
-      cpSync(channelsJson, resolve11(state, "channels.json"));
+    mkdirSync6(state, { recursive: true });
+    const channelsJson = resolve12(tempDir, "state/channels.json");
+    if (existsSync10(channelsJson)) {
+      cpSync(channelsJson, resolve12(state, "channels.json"));
     }
-    const envJson = resolve11(tempDir, "state/env.json");
-    if (existsSync9(envJson)) {
-      cpSync(envJson, resolve11(state, "env.json"));
+    const envJson = resolve12(tempDir, "state/env.json");
+    if (existsSync10(envJson)) {
+      cpSync(envJson, resolve12(state, "env.json"));
     }
     const port = nextPort();
     addMind(name, port, manifest.stage, manifest.template);
@@ -3057,36 +2785,36 @@ async function importFromFullArchive(c, tempDir, extractedMindDir, nameOverride,
     } catch (err) {
       logger_default.warn(`failed to set template hash for ${name}`, logger_default.errorData(err));
     }
-    const homeDir = resolve11(dest, "home");
+    const homeDir = resolve12(dest, "home");
     ensureVoluteGroup();
     createMindUser(name, homeDir);
     chownMindDir(dest, name);
     await npmInstallAsMind(dest, name);
     await importHistoryFromArchive(name, tempDir);
     importSessionsFromArchive(dest, tempDir);
-    if (!existsSync9(resolve11(dest, ".git"))) {
+    if (!existsSync10(resolve12(dest, ".git"))) {
       try {
-        const env = isIsolationEnabled() ? { ...process.env, HOME: resolve11(dest, "home") } : void 0;
+        const env = isIsolationEnabled() ? { ...process.env, HOME: resolve12(dest, "home") } : void 0;
         await gitExec(["init"], { cwd: dest, mindName: name, env });
         await configureGitIdentity(name, { cwd: dest, mindName: name, env });
         await gitExec(["add", "-A"], { cwd: dest, mindName: name, env });
         await gitExec(["commit", "-m", "import from archive"], { cwd: dest, mindName: name, env });
       } catch (err) {
         logger_default.error(`git setup failed for imported mind ${name}`, logger_default.errorData(err));
-        rmSync3(resolve11(dest, ".git"), { recursive: true, force: true });
+        rmSync4(resolve12(dest, ".git"), { recursive: true, force: true });
       }
     }
     chownMindDir(dest, name);
-    rmSync3(tempDir, { recursive: true, force: true });
+    rmSync4(tempDir, { recursive: true, force: true });
     return c.json({ ok: true, name, port, message: `Imported mind: ${name} (port ${port})` });
   } catch (err) {
-    if (existsSync9(dest)) rmSync3(dest, { recursive: true, force: true });
+    if (existsSync10(dest)) rmSync4(dest, { recursive: true, force: true });
     try {
       removeMind(name);
     } catch (cleanupErr) {
       logger_default.error(`Failed to clean up registry for ${name}`, logger_default.errorData(cleanupErr));
     }
-    rmSync3(tempDir, { recursive: true, force: true });
+    rmSync4(tempDir, { recursive: true, force: true });
     return c.json({ error: err instanceof Error ? err.message : "Failed to import mind" }, 500);
   }
 }
@@ -3097,7 +2825,7 @@ async function importFromHomeOnlyArchive(c, tempDir, extractedMindDir, nameOverr
   if (findMind(name)) return c.json({ error: `Mind already exists: ${name}` }, 409);
   ensureVoluteHome();
   const dest = mindDir(name);
-  if (existsSync9(dest)) return c.json({ error: "Mind directory already exists" }, 409);
+  if (existsSync10(dest)) return c.json({ error: "Mind directory already exists" }, 409);
   const templatesRoot = findTemplatesRoot();
   const { composedDir, manifest: templateManifest } = composeTemplate(
     templatesRoot,
@@ -3106,40 +2834,40 @@ async function importFromHomeOnlyArchive(c, tempDir, extractedMindDir, nameOverr
   try {
     copyTemplateToDir(composedDir, dest, name, templateManifest);
     applyInitFiles(dest);
-    const extractedHome = resolve11(extractedMindDir, "home");
-    if (existsSync9(extractedHome)) {
-      cpSync(extractedHome, resolve11(dest, "home"), { recursive: true });
+    const extractedHome = resolve12(extractedMindDir, "home");
+    if (existsSync10(extractedHome)) {
+      cpSync(extractedHome, resolve12(dest, "home"), { recursive: true });
     }
-    const extractedMindInternal = resolve11(extractedMindDir, ".mind");
-    if (existsSync9(extractedMindInternal)) {
-      cpSync(extractedMindInternal, resolve11(dest, ".mind"), { recursive: true });
+    const extractedMindInternal = resolve12(extractedMindDir, ".mind");
+    if (existsSync10(extractedMindInternal)) {
+      cpSync(extractedMindInternal, resolve12(dest, ".mind"), { recursive: true });
     }
-    const identityDir = resolve11(dest, ".mind/identity");
+    const identityDir = resolve12(dest, ".mind/identity");
     let publicKeyPem;
-    if (!manifest.includes.identity || !existsSync9(resolve11(identityDir, "private.pem"))) {
+    if (!manifest.includes.identity || !existsSync10(resolve12(identityDir, "private.pem"))) {
       ({ publicKeyPem } = generateIdentity(dest));
     } else {
-      publicKeyPem = readFileSync8(resolve11(identityDir, "public.pem"), "utf-8");
+      publicKeyPem = readFileSync9(resolve12(identityDir, "public.pem"), "utf-8");
     }
-    const promptsPath = resolve11(dest, "home/.config/prompts.json");
-    if (!existsSync9(promptsPath)) {
+    const promptsPath = resolve12(dest, "home/.config/prompts.json");
+    if (!existsSync10(promptsPath)) {
       const mindPrompts = await getMindPromptDefaults();
-      writeFileSync6(promptsPath, `${JSON.stringify(mindPrompts, null, 2)}
+      writeFileSync7(promptsPath, `${JSON.stringify(mindPrompts, null, 2)}
 `);
     }
     const state = stateDir(name);
-    mkdirSync5(state, { recursive: true });
-    const channelsJson = resolve11(tempDir, "state/channels.json");
-    if (existsSync9(channelsJson)) {
-      cpSync(channelsJson, resolve11(state, "channels.json"));
+    mkdirSync6(state, { recursive: true });
+    const channelsJson = resolve12(tempDir, "state/channels.json");
+    if (existsSync10(channelsJson)) {
+      cpSync(channelsJson, resolve12(state, "channels.json"));
     }
-    const envJson = resolve11(tempDir, "state/env.json");
-    if (existsSync9(envJson)) {
-      cpSync(envJson, resolve11(state, "env.json"));
+    const envJson = resolve12(tempDir, "state/env.json");
+    if (existsSync10(envJson)) {
+      cpSync(envJson, resolve12(state, "env.json"));
     }
     const port = nextPort();
     addMind(name, port, manifest.stage, manifest.template);
-    const homeDir = resolve11(dest, "home");
+    const homeDir = resolve12(dest, "home");
     ensureVoluteGroup();
     createMindUser(name, homeDir);
     chownMindDir(dest, name);
@@ -3152,7 +2880,7 @@ async function importFromHomeOnlyArchive(c, tempDir, extractedMindDir, nameOverr
       await initTemplateBranch(dest, composedDir, templateManifest, name, env);
     } catch (err) {
       logger_default.error(`git setup failed for imported mind ${name}`, logger_default.errorData(err));
-      rmSync3(resolve11(dest, ".git"), { recursive: true, force: true });
+      rmSync4(resolve12(dest, ".git"), { recursive: true, force: true });
       gitWarning = "Git setup failed \u2014 variants and upgrades won't be available until git is initialized.";
     }
     try {
@@ -3176,7 +2904,7 @@ async function importFromHomeOnlyArchive(c, tempDir, extractedMindDir, nameOverr
     publishPublicKey(name, publicKeyPem).catch(
       (err) => logger_default.warn(`failed to publish key for ${name}`, { error: err.message })
     );
-    rmSync3(tempDir, { recursive: true, force: true });
+    rmSync4(tempDir, { recursive: true, force: true });
     return c.json({
       ok: true,
       name,
@@ -3187,24 +2915,24 @@ async function importFromHomeOnlyArchive(c, tempDir, extractedMindDir, nameOverr
       ...skillWarnings.length > 0 && { skillWarnings }
     });
   } catch (err) {
-    if (existsSync9(dest)) rmSync3(dest, { recursive: true, force: true });
+    if (existsSync10(dest)) rmSync4(dest, { recursive: true, force: true });
     try {
       removeMind(name);
     } catch (cleanupErr) {
       logger_default.error(`Failed to clean up registry for ${name}`, logger_default.errorData(cleanupErr));
     }
-    rmSync3(tempDir, { recursive: true, force: true });
+    rmSync4(tempDir, { recursive: true, force: true });
     return c.json({ error: err instanceof Error ? err.message : "Failed to import mind" }, 500);
   } finally {
-    rmSync3(composedDir, { recursive: true, force: true });
+    rmSync4(composedDir, { recursive: true, force: true });
   }
 }
 async function importHistoryFromArchive(name, tempDir) {
-  const historyJsonl = resolve11(tempDir, "history.jsonl");
-  if (!existsSync9(historyJsonl)) return;
+  const historyJsonl = resolve12(tempDir, "history.jsonl");
+  if (!existsSync10(historyJsonl)) return;
   try {
     const db = await getDb();
-    const lines = readFileSync8(historyJsonl, "utf-8").trim().split("\n");
+    const lines = readFileSync9(historyJsonl, "utf-8").trim().split("\n");
     let imported = 0;
     let failed = 0;
     for (const line of lines) {
@@ -3240,13 +2968,13 @@ async function importHistoryFromArchive(name, tempDir) {
   }
 }
 function importSessionsFromArchive(dest, tempDir) {
-  const sessionsDir = resolve11(tempDir, "sessions");
-  if (!existsSync9(sessionsDir)) return;
+  const sessionsDir = resolve12(tempDir, "sessions");
+  if (!existsSync10(sessionsDir)) return;
   try {
-    const destSessions = resolve11(dest, ".mind/sessions");
-    mkdirSync5(destSessions, { recursive: true });
+    const destSessions = resolve12(dest, ".mind/sessions");
+    mkdirSync6(destSessions, { recursive: true });
     for (const file of readdirSync4(sessionsDir)) {
-      cpSync(resolve11(sessionsDir, file), resolve11(destSessions, file));
+      cpSync(resolve12(sessionsDir, file), resolve12(destSessions, file));
     }
   } catch (err) {
     logger_default.error("Failed to import sessions from archive", logger_default.errorData(err));
@@ -3269,7 +2997,7 @@ var app11 = new Hono11().post("/", requireAdmin, zValidator3("json", createMindS
   if (findMind(name)) return c.json({ error: `Mind already exists: ${name}` }, 409);
   ensureVoluteHome();
   const dest = mindDir(name);
-  if (existsSync9(dest)) return c.json({ error: "Mind directory already exists" }, 409);
+  if (existsSync10(dest)) return c.json({ error: "Mind directory already exists" }, 409);
   const templatesRoot = findTemplatesRoot();
   const { composedDir, manifest } = composeTemplate(templatesRoot, template);
   try {
@@ -3283,15 +3011,15 @@ var app11 = new Hono11().post("/", requireAdmin, zValidator3("json", createMindS
       writeVoluteConfig(dest, seedConfig);
     }
     if (body.model) {
-      const configPath2 = resolve11(dest, "home/.config/config.json");
-      const existing = existsSync9(configPath2) ? JSON.parse(readFileSync8(configPath2, "utf-8")) : {};
+      const configPath2 = resolve12(dest, "home/.config/config.json");
+      const existing = existsSync10(configPath2) ? JSON.parse(readFileSync9(configPath2, "utf-8")) : {};
       existing.model = body.model;
-      writeFileSync6(configPath2, `${JSON.stringify(existing, null, 2)}
+      writeFileSync7(configPath2, `${JSON.stringify(existing, null, 2)}
 `);
     }
     const mindPrompts = await getMindPromptDefaults();
-    writeFileSync6(
-      resolve11(dest, "home/.config/prompts.json"),
+    writeFileSync7(
+      resolve12(dest, "home/.config/prompts.json"),
       `${JSON.stringify(mindPrompts, null, 2)}
 `
     );
@@ -3302,7 +3030,7 @@ var app11 = new Hono11().post("/", requireAdmin, zValidator3("json", createMindS
     } catch (err) {
       logger_default.warn(`failed to set template hash for ${name}`, logger_default.errorData(err));
     }
-    const homeDir = resolve11(dest, "home");
+    const homeDir = resolve12(dest, "home");
     ensureVoluteGroup();
     createMindUser(name, homeDir);
     chownMindDir(dest, name);
@@ -3315,7 +3043,7 @@ var app11 = new Hono11().post("/", requireAdmin, zValidator3("json", createMindS
       await initTemplateBranch(dest, composedDir, manifest, name, env);
     } catch (err) {
       logger_default.error(`git setup failed for ${name}`, logger_default.errorData(err));
-      rmSync3(resolve11(dest, ".git"), { recursive: true, force: true });
+      rmSync4(resolve12(dest, ".git"), { recursive: true, force: true });
       gitWarning = "Git setup failed \u2014 variants and upgrades won't be available until git is initialized.";
     }
     try {
@@ -3330,7 +3058,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;
-      writeFileSync6(resolve11(dest, "home/SOUL.md"), seedSoul);
+      writeFileSync7(resolve12(dest, "home/SOUL.md"), seedSoul);
     }
     const skillSet = body.skills ?? (body.stage === "seed" ? SEED_SKILLS : STANDARD_SKILLS);
     const skillWarnings = [];
@@ -3345,11 +3073,11 @@ The human who planted you described you as: "${body.description}"
     if (body.stage !== "seed") {
       const customSoul = await getPromptIfCustom("default_soul");
       if (customSoul) {
-        writeFileSync6(resolve11(dest, "home/SOUL.md"), customSoul.replace(/\{\{name\}\}/g, name));
+        writeFileSync7(resolve12(dest, "home/SOUL.md"), customSoul.replace(/\{\{name\}\}/g, name));
       }
       const customMemory = await getPromptIfCustom("default_memory");
       if (customMemory) {
-        writeFileSync6(resolve11(dest, "home/MEMORY.md"), customMemory);
+        writeFileSync7(resolve12(dest, "home/MEMORY.md"), customMemory);
       }
     }
     publishPublicKey(name, publicKeyPem).catch(
@@ -3376,14 +3104,14 @@ The human who planted you described you as: "${body.description}"
       ...skillWarnings.length > 0 && { skillWarnings }
     });
   } catch (err) {
-    if (existsSync9(dest)) rmSync3(dest, { recursive: true, force: true });
+    if (existsSync10(dest)) rmSync4(dest, { recursive: true, force: true });
     try {
       removeMind(name);
     } catch {
     }
     return c.json({ error: err instanceof Error ? err.message : "Failed to create mind" }, 500);
   } finally {
-    rmSync3(composedDir, { recursive: true, force: true });
+    rmSync4(composedDir, { recursive: true, force: true });
   }
 }).post("/import", requireAdmin, async (c) => {
   let body;
@@ -3396,13 +3124,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 || !existsSync9(resolve11(wsDir, "SOUL.md")) || !existsSync9(resolve11(wsDir, "IDENTITY.md"))) {
+  if (!wsDir || !existsSync10(resolve12(wsDir, "SOUL.md")) || !existsSync10(resolve12(wsDir, "IDENTITY.md"))) {
     return c.json({ error: "Invalid workspace: missing SOUL.md or IDENTITY.md" }, 400);
   }
-  const soul = readFileSync8(resolve11(wsDir, "SOUL.md"), "utf-8");
-  const identity = readFileSync8(resolve11(wsDir, "IDENTITY.md"), "utf-8");
-  const userPath = resolve11(wsDir, "USER.md");
-  const user = existsSync9(userPath) ? readFileSync8(userPath, "utf-8") : "";
+  const soul = readFileSync9(resolve12(wsDir, "SOUL.md"), "utf-8");
+  const identity = readFileSync9(resolve12(wsDir, "IDENTITY.md"), "utf-8");
+  const userPath = resolve12(wsDir, "USER.md");
+  const user = existsSync10(userPath) ? readFileSync9(userPath, "utf-8") : "";
   const name = body.name ?? parseNameFromIdentity(identity) ?? "imported-mind";
   const template = body.template ?? "claude";
   const nameErr = validateMindName(name);
@@ -3422,33 +3150,33 @@ ${user.trimEnd()}
 ` : "";
   ensureVoluteHome();
   const dest = mindDir(name);
-  if (existsSync9(dest)) return c.json({ error: "Mind directory already exists" }, 409);
+  if (existsSync10(dest)) return c.json({ error: "Mind directory already exists" }, 409);
   const templatesRoot = findTemplatesRoot();
   const { composedDir, manifest } = composeTemplate(templatesRoot, template);
   try {
     copyTemplateToDir(composedDir, dest, name, manifest);
     applyInitFiles(dest);
     const { publicKeyPem: importPublicKey } = generateIdentity(dest);
-    writeFileSync6(resolve11(dest, "home/SOUL.md"), mergedSoul);
-    const wsMemoryPath = resolve11(wsDir, "MEMORY.md");
-    const hasMemory = existsSync9(wsMemoryPath);
+    writeFileSync7(resolve12(dest, "home/SOUL.md"), mergedSoul);
+    const wsMemoryPath = resolve12(wsDir, "MEMORY.md");
+    const hasMemory = existsSync10(wsMemoryPath);
     if (hasMemory) {
-      const existingMemory = readFileSync8(wsMemoryPath, "utf-8");
-      writeFileSync6(
-        resolve11(dest, "home/MEMORY.md"),
+      const existingMemory = readFileSync9(wsMemoryPath, "utf-8");
+      writeFileSync7(
+        resolve12(dest, "home/MEMORY.md"),
         `${existingMemory.trimEnd()}${mergedMemoryExtra}`
       );
     } else if (user) {
-      writeFileSync6(resolve11(dest, "home/MEMORY.md"), `${user.trimEnd()}
+      writeFileSync7(resolve12(dest, "home/MEMORY.md"), `${user.trimEnd()}
 `);
     }
-    const wsMemoryDir = resolve11(wsDir, "memory");
+    const wsMemoryDir = resolve12(wsDir, "memory");
     let dailyLogCount = 0;
-    if (existsSync9(wsMemoryDir)) {
-      const destMemoryDir = resolve11(dest, "home/memory");
+    if (existsSync10(wsMemoryDir)) {
+      const destMemoryDir = resolve12(dest, "home/memory");
       const files = readdirSync4(wsMemoryDir).filter((f) => f.endsWith(".md"));
       for (const file of files) {
-        cpSync(resolve11(wsMemoryDir, file), resolve11(destMemoryDir, file));
+        cpSync(resolve12(wsMemoryDir, file), resolve12(destMemoryDir, file));
       }
       dailyLogCount = files.length;
     }
@@ -3459,7 +3187,7 @@ ${user.trimEnd()}
     } catch (err) {
       logger_default.warn(`failed to set template hash for ${name}`, logger_default.errorData(err));
     }
-    const homeDir = resolve11(dest, "home");
+    const homeDir = resolve12(dest, "home");
     ensureVoluteGroup();
     createMindUser(name, homeDir);
     chownMindDir(dest, name);
@@ -3467,20 +3195,20 @@ ${user.trimEnd()}
     if (!hasMemory && dailyLogCount > 0) {
       await consolidateMemory(dest);
     }
-    const env = isIsolationEnabled() ? { ...process.env, HOME: resolve11(dest, "home") } : void 0;
+    const env = isIsolationEnabled() ? { ...process.env, HOME: resolve12(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 ? resolve11(body.sessionPath) : findOpenClawSession(wsDir);
-    if (sessionFile && existsSync9(sessionFile)) {
+    const sessionFile = body.sessionPath ? resolve12(body.sessionPath) : findOpenClawSession(wsDir);
+    if (sessionFile && existsSync10(sessionFile)) {
       if (template === "pi") {
         importPiSession(sessionFile, dest);
       } else if (template === "claude") {
         const sessionId = convertSession({ sessionPath: sessionFile, projectDir: dest });
-        const mindRuntimeDir = resolve11(dest, ".mind");
-        mkdirSync5(mindRuntimeDir, { recursive: true });
-        writeFileSync6(resolve11(mindRuntimeDir, "session.json"), JSON.stringify({ sessionId }));
+        const mindRuntimeDir = resolve12(dest, ".mind");
+        mkdirSync6(mindRuntimeDir, { recursive: true });
+        writeFileSync7(resolve12(mindRuntimeDir, "session.json"), JSON.stringify({ sessionId }));
       }
     }
     importOpenClawConnectors(name, dest);
@@ -3495,14 +3223,14 @@ ${user.trimEnd()}
     );
     return c.json({ ok: true, name, port, message: `Imported mind: ${name} (port ${port})` });
   } catch (err) {
-    if (existsSync9(dest)) rmSync3(dest, { recursive: true, force: true });
+    if (existsSync10(dest)) rmSync4(dest, { recursive: true, force: true });
     try {
       removeMind(name);
     } catch {
     }
     return c.json({ error: err instanceof Error ? err.message : "Failed to import mind" }, 500);
   } finally {
-    rmSync3(composedDir, { recursive: true, force: true });
+    rmSync4(composedDir, { recursive: true, force: true });
   }
 }).get("/", async (c) => {
   const entries = readRegistry();
@@ -3511,7 +3239,7 @@ ${user.trimEnd()}
     const db = await getDb();
     const lastActiveRows = await db.select({
       mind: mindHistory.mind,
-      lastActiveAt: sql2`MAX(${mindHistory.created_at})`
+      lastActiveAt: sql`MAX(${mindHistory.created_at})`
     }).from(mindHistory).groupBy(mindHistory.mind);
     lastActiveMap = new Map(lastActiveRows.map((r) => [r.mind, r.lastActiveAt]));
   } catch {
@@ -3519,7 +3247,7 @@ ${user.trimEnd()}
   const minds = await Promise.all(
     entries.map(async (entry) => {
       const mindStatus = await getMindStatus(entry.name, entry.port);
-      const hasPages = existsSync9(resolve11(mindDir(entry.name), "home", "pages"));
+      const hasPages = existsSync10(resolve12(mindDir(entry.name), "home", "pages"));
       return {
         ...entry,
         ...mindStatus,
@@ -3537,7 +3265,7 @@ ${user.trimEnd()}
   const name = c.req.param("name");
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  if (!existsSync9(mindDir(name))) return c.json({ error: "Mind directory missing" }, 404);
+  if (!existsSync10(mindDir(name))) return c.json({ error: "Mind directory missing" }, 404);
   const mindStatus = await getMindStatus(name, entry.port);
   const variants = readVariants(name);
   const manager = getMindManager();
@@ -3552,7 +3280,7 @@ ${user.trimEnd()}
       return { name: v.name, port: v.port, status: variantStatus };
     })
   );
-  const hasPages = existsSync9(resolve11(mindDir(name), "home", "pages"));
+  const hasPages = existsSync10(resolve12(mindDir(name), "home", "pages"));
   return c.json({ ...entry, ...mindStatus, variants: variantStatuses, hasPages });
 }).post("/:name/start", requireAdmin, async (c) => {
   const name = c.req.param("name");
@@ -3566,7 +3294,7 @@ ${user.trimEnd()}
     targetPort = variant.port;
   } else {
     const dir = mindDir(baseName);
-    if (!existsSync9(dir)) return c.json({ error: "Mind directory missing" }, 404);
+    if (!existsSync10(dir)) return c.json({ error: "Mind directory missing" }, 404);
   }
   if (getMindManager().isRunning(name)) {
     return c.json({ error: "Mind already running" }, 409);
@@ -3589,7 +3317,7 @@ ${user.trimEnd()}
     targetPort = variant.port;
   } else {
     const dir = mindDir(baseName);
-    if (!existsSync9(dir)) return c.json({ error: "Mind directory missing" }, 404);
+    if (!existsSync10(dir)) return c.json({ error: "Mind directory missing" }, 404);
   }
   let context;
   const contentType = c.req.header("content-type");
@@ -3616,7 +3344,7 @@ ${user.trimEnd()}
       const variant = findVariant(baseName, mergeVariantName);
       if (variant) {
         const projectRoot = mindDir(baseName);
-        if (existsSync9(variant.path)) {
+        if (existsSync10(variant.path)) {
           const status = (await gitExec(["status", "--porcelain"], { cwd: variant.path })).trim();
           if (status) {
             try {
@@ -3658,7 +3386,7 @@ ${user.trimEnd()}
     if (context?.type === "sprouted" && !variantName) {
       try {
         const db = await getDb();
-        const activeConvs = await db.select({ id: conversations.id }).from(conversations).where(eq4(conversations.mind_name, baseName)).all();
+        const activeConvs = await db.select({ id: conversations.id }).from(conversations).where(eq2(conversations.mind_name, baseName)).all();
         for (const conv of activeConvs) {
           await addMessage(conv.id, "assistant", "system", [
             { type: "text", text: "[seed has sprouted]" }
@@ -3696,7 +3424,7 @@ ${user.trimEnd()}
   const name = c.req.param("name");
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const { getSleepManagerIfReady } = await import("./sleep-manager-3RWUX2ZR.js");
+  const { getSleepManagerIfReady } = await import("./sleep-manager-XXSWQQLE.js");
   const sm = getSleepManagerIfReady();
   if (!sm) return c.json({ error: "Sleep manager not initialized" }, 503);
   return c.json(sm.getState(name));
@@ -3704,7 +3432,7 @@ ${user.trimEnd()}
   const name = c.req.param("name");
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const { getSleepManagerIfReady } = await import("./sleep-manager-3RWUX2ZR.js");
+  const { getSleepManagerIfReady } = await import("./sleep-manager-XXSWQQLE.js");
   const sm = getSleepManagerIfReady();
   if (!sm) return c.json({ error: "Sleep manager not initialized" }, 503);
   if (sm.isSleeping(name)) return c.json({ error: "Mind is already sleeping" }, 409);
@@ -3724,7 +3452,7 @@ ${user.trimEnd()}
   const name = c.req.param("name");
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const { getSleepManagerIfReady } = await import("./sleep-manager-3RWUX2ZR.js");
+  const { getSleepManagerIfReady } = await import("./sleep-manager-XXSWQQLE.js");
   const sm = getSleepManagerIfReady();
   if (!sm) return c.json({ error: "Sleep manager not initialized" }, 503);
   if (!sm.isSleeping(name)) return c.json({ error: "Mind is not sleeping" }, 409);
@@ -3734,7 +3462,7 @@ ${user.trimEnd()}
   const name = c.req.param("name");
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const { getSleepManagerIfReady } = await import("./sleep-manager-3RWUX2ZR.js");
+  const { getSleepManagerIfReady } = await import("./sleep-manager-XXSWQQLE.js");
   const sm = getSleepManagerIfReady();
   if (!sm) return c.json({ error: "Sleep manager not initialized" }, 503);
   const flushed = await sm.flushQueuedMessages(name);
@@ -3767,11 +3495,11 @@ ${user.trimEnd()}
   removeMind(name);
   await deleteMindUser2(name);
   const state = stateDir(name);
-  if (existsSync9(state)) {
-    rmSync3(state, { recursive: true, force: true });
+  if (existsSync10(state)) {
+    rmSync4(state, { recursive: true, force: true });
   }
-  if (force && existsSync9(dir)) {
-    rmSync3(dir, { recursive: true, force: true });
+  if (force && existsSync10(dir)) {
+    rmSync4(dir, { recursive: true, force: true });
     deleteMindUser(name);
   }
   fireWebhook({
@@ -3785,7 +3513,7 @@ ${user.trimEnd()}
   const entry = findMind(mindName);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const dir = mindDir(mindName);
-  if (!existsSync9(dir)) return c.json({ error: "Mind directory missing" }, 404);
+  if (!existsSync10(dir)) return c.json({ error: "Mind directory missing" }, 404);
   let body = {};
   try {
     body = await c.req.json();
@@ -3794,15 +3522,15 @@ ${user.trimEnd()}
   const template = body.template ?? entry.template ?? "claude";
   const UPGRADE_VARIANT = "upgrade";
   if (body.abort) {
-    const worktreeDir2 = resolve11(dir, ".variants", UPGRADE_VARIANT);
-    if (!existsSync9(worktreeDir2)) {
+    const worktreeDir2 = resolve12(dir, ".variants", UPGRADE_VARIANT);
+    if (!existsSync10(worktreeDir2)) {
       return c.json({ error: "No upgrade in progress" }, 400);
     }
     try {
       try {
-        const gitDirContent = readFileSync8(resolve11(worktreeDir2, ".git"), "utf-8").trim();
+        const gitDirContent = readFileSync9(resolve12(worktreeDir2, ".git"), "utf-8").trim();
         const gitDir = gitDirContent.replace("gitdir: ", "");
-        if (existsSync9(resolve11(gitDir, "MERGE_HEAD"))) {
+        if (existsSync10(resolve12(gitDir, "MERGE_HEAD"))) {
           await gitExec(["merge", "--abort"], { cwd: worktreeDir2 });
         }
       } catch {
@@ -3817,8 +3545,8 @@ ${user.trimEnd()}
     }
   }
   if (body.continue) {
-    const worktreeDir2 = resolve11(dir, ".variants", UPGRADE_VARIANT);
-    if (!existsSync9(worktreeDir2)) {
+    const worktreeDir2 = resolve12(dir, ".variants", UPGRADE_VARIANT);
+    if (!existsSync10(worktreeDir2)) {
       return c.json({ error: "No upgrade in progress" }, 400);
     }
     const status = await gitExec(["status", "--porcelain"], { cwd: worktreeDir2 });
@@ -3862,23 +3590,23 @@ ${user.trimEnd()}
       );
     }
   }
-  const worktreeDir = resolve11(dir, ".variants", UPGRADE_VARIANT);
-  if (existsSync9(worktreeDir)) {
+  const worktreeDir = resolve12(dir, ".variants", UPGRADE_VARIANT);
+  if (existsSync10(worktreeDir)) {
     return c.json(
       { error: "Upgrade variant already exists. Use continue or delete it first." },
       409
     );
   }
-  if (!existsSync9(resolve11(dir, ".git"))) {
+  if (!existsSync10(resolve12(dir, ".git"))) {
     try {
-      const env = isIsolationEnabled() ? { ...process.env, HOME: resolve11(dir, "home") } : void 0;
+      const env = isIsolationEnabled() ? { ...process.env, HOME: resolve12(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(resolve11(dir, ".git"), { recursive: true, force: true });
+      rmSync4(resolve12(dir, ".git"), { recursive: true, force: true });
       return c.json(
         {
           error: `Git initialization failed: ${err instanceof Error ? err.message : String(err)}`
@@ -3892,7 +3620,7 @@ ${user.trimEnd()}
     await gitExec(["branch", "-D", UPGRADE_VARIANT], { cwd: dir });
   } catch {
   }
-  if (!existsSync9(resolve11(dir, "home", "shared"))) {
+  if (!existsSync10(resolve12(dir, "home", "shared"))) {
     try {
       await addSharedWorktree(mindName, dir);
     } catch (err) {
@@ -3903,9 +3631,9 @@ ${user.trimEnd()}
     }
   }
   await updateTemplateBranch(dir, template, mindName);
-  const parentDir = resolve11(dir, ".variants");
-  if (!existsSync9(parentDir)) {
-    mkdirSync5(parentDir, { recursive: true });
+  const parentDir = resolve12(dir, ".variants");
+  if (!existsSync10(parentDir)) {
+    mkdirSync6(parentDir, { recursive: true });
   }
   await gitExec(["worktree", "add", "-b", UPGRADE_VARIANT, worktreeDir], { cwd: dir });
   const hasConflicts = await mergeTemplateBranch(worktreeDir);
@@ -3952,7 +3680,7 @@ ${user.trimEnd()}
     if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
   }
   try {
-    const { getSleepManagerIfReady } = await import("./sleep-manager-3RWUX2ZR.js");
+    const { getSleepManagerIfReady } = await import("./sleep-manager-XXSWQQLE.js");
     const sm = getSleepManagerIfReady();
     if (sm?.isSleeping(baseName)) {
       const body2 = await c.req.text();
@@ -3994,21 +3722,10 @@ ${user.trimEnd()}
     logger_default.error(`failed to parse message body for ${baseName}`, logger_default.errorData(err));
   }
   const channel = parsed?.channel ?? "unknown";
-  const db = await getDb();
   if (parsed) {
-    try {
-      const sender2 = parsed.sender ?? null;
-      const content = extractTextContent(parsed.content);
-      await db.insert(mindHistory).values({
-        mind: baseName,
-        type: "inbound",
-        channel,
-        sender: sender2,
-        content
-      });
-    } catch (err) {
-      logger_default.error(`failed to persist inbound message for ${baseName}`, logger_default.errorData(err));
-    }
+    const sender2 = parsed.sender ?? null;
+    const content = extractTextContent(parsed.content);
+    await recordInbound(baseName, channel, sender2, content);
   }
   const budget = getTokenBudget();
   const budgetStatus = budget.checkBudget(baseName);
@@ -4060,7 +3777,8 @@ ${user.trimEnd()}
   const seedEntry = findMind(baseName);
   if (seedEntry?.stage === "seed") {
     try {
-      const countResult = await db.select({ count: sql2`count(*)` }).from(mindHistory).where(eq4(mindHistory.mind, baseName));
+      const db = await getDb();
+      const countResult = await db.select({ count: sql`count(*)` }).from(mindHistory).where(eq2(mindHistory.mind, baseName));
       const msgCount = countResult[0]?.count ?? 0;
       if (msgCount >= 10 && msgCount % 10 === 0) {
         const nudge = "\n[You've been exploring for a while. Whenever you feel ready, write your SOUL.md and MEMORY.md, then run volute mind sprout.]";
@@ -4105,13 +3823,13 @@ ${user.trimEnd()}
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const dir = mindDir(name);
-  if (!existsSync9(dir)) return c.json({ error: "Mind directory missing" }, 404);
+  if (!existsSync10(dir)) return c.json({ error: "Mind directory missing" }, 404);
   let config = readVoluteConfig(dir);
   if (!config && entry.template === "pi") {
-    const piConfigPath = resolve11(dir, "home/.config/config.json");
-    if (existsSync9(piConfigPath)) {
+    const piConfigPath = resolve12(dir, "home/.config/config.json");
+    if (existsSync10(piConfigPath)) {
       try {
-        config = JSON.parse(readFileSync8(piConfigPath, "utf-8"));
+        config = JSON.parse(readFileSync9(piConfigPath, "utf-8"));
       } catch {
       }
     }
@@ -4148,7 +3866,7 @@ ${user.trimEnd()}
     const entry = findMind(name);
     if (!entry) return c.json({ error: "Mind not found" }, 404);
     const dir = mindDir(name);
-    if (!existsSync9(dir)) return c.json({ error: "Mind directory missing" }, 404);
+    if (!existsSync10(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;
@@ -4211,7 +3929,7 @@ ${user.trimEnd()}
   } catch (err) {
     logger_default.error(`failed to persist event for ${baseName}`, logger_default.errorData(err));
   }
-  publish2(baseName, {
+  publish(baseName, {
     mind: baseName,
     type: body.type,
     session: body.session,
@@ -4261,14 +3979,29 @@ ${user.trimEnd()}
 
 `));
       };
-      const unsubscribe = subscribe3(baseName, (event) => {
+      let unsubscribe;
+      const pingInterval = setInterval(() => {
+        try {
+          controller.enqueue(encoder.encode(": ping\n\n"));
+        } catch {
+          clearInterval(pingInterval);
+          unsubscribe?.();
+        }
+      }, 15e3);
+      unsubscribe = subscribe2(baseName, (event) => {
         if (typeFilter && !typeFilter.includes(event.type)) return;
         if (sessionFilter && event.session !== sessionFilter) return;
         if (channelFilter && event.channel !== channelFilter) return;
-        send5(JSON.stringify(event));
+        try {
+          send5(JSON.stringify(event));
+        } catch {
+          clearInterval(pingInterval);
+          unsubscribe?.();
+        }
       });
       c.req.raw.signal.addEventListener("abort", () => {
-        unsubscribe();
+        clearInterval(pingInterval);
+        unsubscribe?.();
         try {
           controller.close();
         } catch {
@@ -4314,22 +4047,22 @@ ${user.trimEnd()}
   const db = await getDb();
   const rows = await db.select({
     session: mindHistory.session,
-    started_at: sql2`MIN(${mindHistory.created_at})`,
-    event_count: sql2`COUNT(*)`,
-    message_count: sql2`SUM(CASE WHEN ${mindHistory.type} IN ('inbound','outbound') THEN 1 ELSE 0 END)`,
-    tool_count: sql2`SUM(CASE WHEN ${mindHistory.type}='tool_use' THEN 1 ELSE 0 END)`
-  }).from(mindHistory).where(and3(eq4(mindHistory.mind, name), sql2`${mindHistory.session} IS NOT NULL`)).groupBy(mindHistory.session).orderBy(sql2`MIN(${mindHistory.created_at}) DESC`);
+    started_at: sql`MIN(${mindHistory.created_at})`,
+    event_count: sql`COUNT(*)`,
+    message_count: sql`SUM(CASE WHEN ${mindHistory.type} IN ('inbound','outbound') THEN 1 ELSE 0 END)`,
+    tool_count: sql`SUM(CASE WHEN ${mindHistory.type}='tool_use' THEN 1 ELSE 0 END)`
+  }).from(mindHistory).where(and(eq2(mindHistory.mind, name), sql`${mindHistory.session} IS NOT NULL`)).groupBy(mindHistory.session).orderBy(sql`MIN(${mindHistory.created_at}) DESC`);
   return c.json(rows);
 }).get("/:name/history/channels", async (c) => {
   const name = c.req.param("name");
   const db = await getDb();
-  const rows = await db.selectDistinct({ channel: mindHistory.channel }).from(mindHistory).where(eq4(mindHistory.mind, name));
+  const rows = await db.selectDistinct({ channel: mindHistory.channel }).from(mindHistory).where(eq2(mindHistory.mind, name));
   return c.json(rows.map((r) => r.channel));
 }).get("/:name/history/export", async (c) => {
   const name = c.req.param("name");
   if (!findMind(name)) return c.json({ error: "Mind not found" }, 404);
   const db = await getDb();
-  const rows = await db.select().from(mindHistory).where(eq4(mindHistory.mind, name));
+  const rows = await db.select().from(mindHistory).where(eq2(mindHistory.mind, name));
   return c.json(rows);
 }).get("/:name/history", async (c) => {
   const name = c.req.param("name");
@@ -4339,24 +4072,24 @@ ${user.trimEnd()}
   const limit = Math.min(Math.max(parseInt(c.req.query("limit") ?? "50", 10) || 50, 1), 200);
   const offset = Math.max(parseInt(c.req.query("offset") ?? "0", 10) || 0, 0);
   const db = await getDb();
-  const conditions = [eq4(mindHistory.mind, name)];
+  const conditions = [eq2(mindHistory.mind, name)];
   if (channel) {
-    conditions.push(eq4(mindHistory.channel, channel));
+    conditions.push(eq2(mindHistory.channel, channel));
   }
   if (session) {
-    conditions.push(eq4(mindHistory.session, session));
+    conditions.push(eq2(mindHistory.session, session));
   }
   if (!full) {
-    conditions.push(sql2`${mindHistory.type} IN ('inbound', 'outbound')`);
+    conditions.push(sql`${mindHistory.type} IN ('inbound', 'outbound')`);
   }
-  const rows = await db.select().from(mindHistory).where(and3(...conditions)).orderBy(desc3(mindHistory.created_at)).limit(limit).offset(offset);
+  const rows = await db.select().from(mindHistory).where(and(...conditions)).orderBy(desc2(mindHistory.created_at)).limit(limit).offset(offset);
   return c.json(rows);
 });
 var minds_default = app11;
 
 // src/web/api/pages.ts
 import { readFile as readFile2, stat as stat2 } from "fs/promises";
-import { extname as extname2, resolve as resolve12 } from "path";
+import { extname as extname3, resolve as resolve13 } from "path";
 import { Hono as Hono12 } from "hono";
 var MIME_TYPES = {
   ".html": "text/html",
@@ -4378,17 +4111,17 @@ var app12 = new Hono12().get("/:name/*", async (c) => {
   const name = c.req.param("name");
   let pagesRoot;
   if (name === "_system") {
-    pagesRoot = resolve12(voluteHome(), "shared", "pages");
+    pagesRoot = resolve13(voluteHome(), "shared", "pages");
   } else {
     if (!findMind(name)) return c.text("Not found", 404);
-    pagesRoot = resolve12(mindDir(name), "home", "pages");
+    pagesRoot = resolve13(mindDir(name), "home", "pages");
   }
   const wildcard = c.req.path.replace(`/pages/${name}`, "") || "/";
-  const requestedPath = resolve12(pagesRoot, wildcard.slice(1));
+  const requestedPath = resolve13(pagesRoot, wildcard.slice(1));
   if (!requestedPath.startsWith(pagesRoot)) return c.text("Forbidden", 403);
   let fileStat = await stat2(requestedPath).catch(() => null);
   if (fileStat?.isDirectory()) {
-    const indexPath = resolve12(requestedPath, "index.html");
+    const indexPath = resolve13(requestedPath, "index.html");
     fileStat = await stat2(indexPath).catch(() => null);
     if (fileStat?.isFile()) {
       const body = await readFile2(indexPath);
@@ -4397,7 +4130,7 @@ var app12 = new Hono12().get("/:name/*", async (c) => {
     return c.text("Not found", 404);
   }
   if (fileStat?.isFile()) {
-    const ext = extname2(requestedPath);
+    const ext = extname3(requestedPath);
     const mime = MIME_TYPES[ext] || "application/octet-stream";
     const body = await readFile2(requestedPath);
     return c.body(body, 200, { "Content-Type": mime });
@@ -4408,7 +4141,7 @@ 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 { eq as eq3, sql as sql2 } from "drizzle-orm";
 import { Hono as Hono13 } from "hono";
 import { z as z4 } from "zod";
 var app13 = new Hono13().get("/", async (c) => {
@@ -4441,9 +4174,9 @@ var app13 = new Hono13().get("/", async (c) => {
   }
   const { content } = c.req.valid("json");
   const db = await getDb();
-  await db.insert(systemPrompts).values({ key, content, updated_at: sql3`(datetime('now'))` }).onConflictDoUpdate({
+  await db.insert(systemPrompts).values({ key, content, updated_at: sql2`(datetime('now'))` }).onConflictDoUpdate({
     target: systemPrompts.key,
-    set: { content, updated_at: sql3`(datetime('now'))` }
+    set: { content, updated_at: sql2`(datetime('now'))` }
   });
   return c.json({ ok: true });
 }).delete("/:key", requireAdmin, async (c) => {
@@ -4452,7 +4185,7 @@ var app13 = new Hono13().get("/", async (c) => {
     return c.json({ error: "Unknown prompt key" }, 404);
   }
   const db = await getDb();
-  await db.delete(systemPrompts).where(eq5(systemPrompts.key, key));
+  await db.delete(systemPrompts).where(eq3(systemPrompts.key, key));
   return c.json({ ok: true });
 });
 var prompts_default = app13;
@@ -4635,9 +4368,9 @@ var app15 = new Hono15().post("/:name/shared/merge", requireAdmin, async (c) =>
 var shared_default = app15;
 
 // src/web/api/skills.ts
-import { existsSync as existsSync10, mkdtempSync, readdirSync as readdirSync5, rmSync as rmSync4 } from "fs";
+import { existsSync as existsSync11, mkdtempSync, readdirSync as readdirSync5, rmSync as rmSync5 } from "fs";
 import { tmpdir } from "os";
-import { join as join2, resolve as resolve13 } from "path";
+import { join as join2, resolve as resolve14 } from "path";
 import AdmZip from "adm-zip";
 import { Hono as Hono16 } from "hono";
 var app16 = new Hono16().get("/", async (c) => {
@@ -4664,19 +4397,19 @@ var app16 = new Hono16().get("/", async (c) => {
   try {
     const zip = new AdmZip(buffer2);
     for (const entry of zip.getEntries()) {
-      const target = resolve13(tmpDir, entry.entryName);
+      const target = resolve14(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 (existsSync10(join2(tmpDir, "SKILL.md"))) {
+    if (existsSync11(join2(tmpDir, "SKILL.md"))) {
       skillDir = tmpDir;
     } else {
       const entries = readdirSync5(tmpDir, { withFileTypes: true }).filter((e) => e.isDirectory());
       for (const entry of entries) {
-        if (existsSync10(join2(tmpDir, entry.name, "SKILL.md"))) {
+        if (existsSync11(join2(tmpDir, entry.name, "SKILL.md"))) {
           skillDir = join2(tmpDir, entry.name);
           break;
         }
@@ -4693,7 +4426,7 @@ var app16 = new Hono16().get("/", async (c) => {
     }
     throw e;
   } finally {
-    rmSync4(tmpDir, { recursive: true, force: true });
+    rmSync5(tmpDir, { recursive: true, force: true });
   }
 }).delete("/:id", requireAdmin, async (c) => {
   const id = c.req.param("id");
@@ -4727,10 +4460,10 @@ var app17 = new Hono17().post("/restart", requireAdmin, (c) => {
       stream.writeSSE({ data: JSON.stringify(entry) }).catch(() => {
       });
     });
-    await new Promise((resolve18) => {
+    await new Promise((resolve19) => {
       stream.onAbort(() => {
         unsubscribe();
-        resolve18();
+        resolve19();
       });
     });
   });
@@ -4760,7 +4493,7 @@ var app18 = new Hono18().post("/:name/typing", zValidator5("json", typingSchema)
   const volutePrefix = "volute:";
   if (channel.startsWith(volutePrefix)) {
     const conversationId = channel.slice(volutePrefix.length);
-    publish(conversationId, { type: "typing", senders: map.get(channel) });
+    publish2(conversationId, { type: "typing", senders: map.get(channel) });
   }
   return c.json({ ok: true });
 }).get("/:name/typing", (c) => {
@@ -4805,8 +4538,8 @@ 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-P5OBDUKI.js");
-  const { getSleepManagerIfReady } = await import("./sleep-manager-3RWUX2ZR.js");
+  const { getMindManager: getMindManager2 } = await import("./mind-manager-ZNRIYEK3.js");
+  const { getSleepManagerIfReady } = await import("./sleep-manager-XXSWQQLE.js");
   const manager = getMindManager2();
   const sm = getSleepManagerIfReady();
   const targetMinds = mindParticipants.map((ap) => {
@@ -4920,11 +4653,15 @@ var app20 = new Hono20().use("*", authMiddleware).post("/minds/:name/chat", zVal
     }
   }
   await addMessage(conversationId, "user", senderName, contentBlocks);
+  const isDM = conv?.type === "dm";
   await fanOutToMinds({
     conversationId,
     contentBlocks,
     senderName,
     convTitle,
+    isDM,
+    channelEntryType: conv?.type === "channel" ? "group" : isDM ? "dm" : "group",
+    slugExtra: conv ? { convType: conv.type, convName: conv.name } : void 0,
     targetName: (username) => username === baseName ? name : username
   });
   return c.json({ ok: true, conversationId });
@@ -4935,7 +4672,7 @@ var app20 = new Hono20().use("*", authMiddleware).post("/minds/:name/chat", zVal
     return c.json({ error: "Conversation not found" }, 404);
   }
   return streamSSE4(c, async (stream) => {
-    const unsubscribe = subscribe2(conversationId, (event) => {
+    const unsubscribe = subscribe3(conversationId, (event) => {
       stream.writeSSE({ data: JSON.stringify(event) }).catch((err) => {
         if (!stream.aborted) logger_default.error("[v1-chat] SSE write error:", logger_default.errorData(err));
       });
@@ -4945,11 +4682,11 @@ var app20 = new Hono20().use("*", authMiddleware).post("/minds/:name/chat", zVal
         if (!stream.aborted) logger_default.error("[v1-chat] SSE ping error:", logger_default.errorData(err));
       });
     }, 15e3);
-    await new Promise((resolve18) => {
+    await new Promise((resolve19) => {
       stream.onAbort(() => {
         unsubscribe();
         clearInterval(keepAlive);
-        resolve18();
+        resolve19();
       });
     });
   });
@@ -5056,6 +4793,15 @@ var app21 = new Hono21().use("*", authMiddleware).get("/", async (c) => {
     participantIds: [...participantIds]
   });
   return c.json(conv, 201);
+}).post("/:id/read", async (c) => {
+  const id = c.req.param("id");
+  const user = c.get("user");
+  if (user.id === 0) return c.json({ ok: true });
+  if (!await isParticipantOrOwner(id, user.id)) {
+    return c.json({ error: "Conversation not found" }, 404);
+  }
+  await markConversationRead(user.id, id);
+  return c.json({ ok: true });
 }).delete("/:id", async (c) => {
   const id = c.req.param("id");
   const user = c.get("user");
@@ -5066,10 +4812,33 @@ var app21 = new Hono21().use("*", authMiddleware).get("/", async (c) => {
 var conversations_default = app21;
 
 // src/web/api/v1/events.ts
-import { desc as desc4 } from "drizzle-orm";
+import { desc as desc3 } from "drizzle-orm";
 import { Hono as Hono22 } from "hono";
 import { streamSSE as streamSSE5 } from "hono/streaming";
 
+// src/lib/events/brain-presence.ts
+var connections = /* @__PURE__ */ new Map();
+function addConnection(username) {
+  const count = connections.get(username) ?? 0;
+  connections.set(username, count + 1);
+  if (count === 0) {
+    broadcast({ type: "brain_online", mind: username, summary: `${username} connected` });
+  }
+}
+function removeConnection(username) {
+  const count = connections.get(username);
+  if (count == null) return;
+  if (count <= 1) {
+    connections.delete(username);
+    broadcast({ type: "brain_offline", mind: username, summary: `${username} disconnected` });
+  } else {
+    connections.set(username, count - 1);
+  }
+}
+function getOnlineBrains() {
+  return [...connections.keys()];
+}
+
 // src/lib/events/event-sequencer.ts
 var BUFFER_SIZE = 1e3;
 var MAX_AGE_MS = 5 * 60 * 1e3;
@@ -5097,6 +4866,10 @@ var app22 = new Hono22().use("*", authMiddleware).get("/", async (c) => {
   const sinceId = since ? Number(since) : 0;
   return streamSSE5(c, async (stream) => {
     const cleanups = [];
+    if (user.user_type === "brain") {
+      addConnection(user.username);
+      cleanups.push(() => removeConnection(user.username));
+    }
     try {
       if (sinceId > 0) {
         const missed = getEventsSince(sinceId);
@@ -5110,7 +4883,7 @@ var app22 = new Hono22().use("*", authMiddleware).get("/", async (c) => {
       let recentActivity = [];
       try {
         const db = await getDb();
-        recentActivity = await db.select().from(activity).orderBy(desc4(activity.created_at)).limit(50);
+        recentActivity = await db.select().from(activity).orderBy(desc3(activity.created_at)).limit(50);
         recentActivity = recentActivity.map((row) => ({
           ...row,
           metadata: row.metadata ? JSON.parse(row.metadata) : null
@@ -5121,6 +4894,13 @@ var app22 = new Hono22().use("*", authMiddleware).get("/", async (c) => {
       let conversations2 = [];
       try {
         conversations2 = await listConversationsWithParticipants(user.id);
+        if (conversations2.length > 0) {
+          const convIds = conversations2.map((c2) => c2.id);
+          const unreads = await getUnreadCounts(user.id, convIds);
+          for (const conv of conversations2) {
+            conv.unreadCount = unreads[conv.id] ?? 0;
+          }
+        }
       } catch (err) {
         logger_default.error("[v1-events] failed to fetch conversations", logger_default.errorData(err));
       }
@@ -5132,7 +4912,8 @@ var app22 = new Hono22().use("*", authMiddleware).get("/", async (c) => {
         conversations: conversations2,
         sites,
         recentPages,
-        activeMinds: getActiveMinds()
+        activeMinds: getActiveMinds(),
+        onlineBrains: getOnlineBrains()
       };
       const snapshotId = bufferEvent(snapshotData);
       await stream.writeSSE({
@@ -5155,7 +4936,7 @@ var app22 = new Hono22().use("*", authMiddleware).get("/", async (c) => {
       });
       cleanups.push(unsubActivity);
       for (const conv of conversations2) {
-        const unsubConv = subscribe2(conv.id, (event) => {
+        const unsubConv = subscribe3(conv.id, (event) => {
           const data = { event: "conversation", conversationId: conv.id, ...event };
           const eventId = bufferEvent(data);
           stream.writeSSE({
@@ -5173,8 +4954,8 @@ var app22 = new Hono22().use("*", authMiddleware).get("/", async (c) => {
         });
       }, 15e3);
       cleanups.push(() => clearInterval(keepAlive));
-      await new Promise((resolve18) => {
-        stream.onAbort(() => resolve18());
+      await new Promise((resolve19) => {
+        stream.onAbort(() => resolve19());
       });
     } finally {
       for (const cleanup of cleanups) {
@@ -5189,16 +4970,16 @@ var app22 = new Hono22().use("*", authMiddleware).get("/", async (c) => {
 var events_default = app22;
 
 // src/web/api/variants.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "fs";
-import { resolve as resolve15 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync8, writeFileSync as writeFileSync8 } from "fs";
+import { resolve as resolve16 } from "path";
 import { Hono as Hono23 } from "hono";
 
 // src/lib/spawn-server.ts
 import { spawn as spawn3 } from "child_process";
-import { closeSync, mkdirSync as mkdirSync6, openSync, readFileSync as readFileSync9 } from "fs";
-import { resolve as resolve14 } from "path";
+import { closeSync, mkdirSync as mkdirSync7, openSync, readFileSync as readFileSync10 } from "fs";
+import { resolve as resolve15 } from "path";
 function tsxBin(cwd) {
-  return resolve14(cwd, "node_modules", ".bin", "tsx");
+  return resolve15(cwd, "node_modules", ".bin", "tsx");
 }
 function spawnServer(cwd, port, options) {
   if (options?.detached) {
@@ -5211,31 +4992,31 @@ function spawnAttached(cwd, port) {
     cwd,
     stdio: ["ignore", "pipe", "pipe"]
   });
-  return new Promise((resolve18) => {
-    const timeout = setTimeout(() => resolve18(null), 3e4);
+  return new Promise((resolve19) => {
+    const timeout = setTimeout(() => resolve19(null), 3e4);
     function checkOutput(data) {
       const match = data.toString().match(/listening on :(\d+)/);
       if (match) {
         clearTimeout(timeout);
-        resolve18({ child, actualPort: parseInt(match[1], 10) });
+        resolve19({ child, actualPort: parseInt(match[1], 10) });
       }
     }
     child.stdout?.on("data", checkOutput);
     child.stderr?.on("data", checkOutput);
     child.on("error", () => {
       clearTimeout(timeout);
-      resolve18(null);
+      resolve19(null);
     });
     child.on("exit", () => {
       clearTimeout(timeout);
-      resolve18(null);
+      resolve19(null);
     });
   });
 }
 function spawnDetached(cwd, port, logDir) {
-  const logsDir = logDir ?? resolve14(cwd, ".mind", "logs");
-  mkdirSync6(logsDir, { recursive: true });
-  const logPath = resolve14(logsDir, "mind.log");
+  const logsDir = logDir ?? resolve15(cwd, ".mind", "logs");
+  mkdirSync7(logsDir, { recursive: true });
+  const logPath = resolve15(logsDir, "mind.log");
   const logFd = openSync(logPath, "a");
   const child = spawn3(tsxBin(cwd), ["src/server.ts", "--port", String(port)], {
     cwd,
@@ -5255,7 +5036,7 @@ function spawnDetached(cwd, port, logDir) {
     }
     const interval = setInterval(() => {
       try {
-        const content = readFileSync9(logPath, "utf-8");
+        const content = readFileSync10(logPath, "utf-8");
         const match = content.match(/listening on :(\d+)/);
         if (match) {
           finish({ child, actualPort: parseInt(match[1], 10) });
@@ -5347,11 +5128,11 @@ var app23 = new Hono23().get("/:name/variants", async (c) => {
   const err = validateBranchName(variantName);
   if (err) return c.json({ error: err }, 400);
   const projectRoot = mindDir(mindName);
-  const variantDir = resolve15(projectRoot, ".variants", variantName);
-  if (existsSync11(variantDir)) {
+  const variantDir = resolve16(projectRoot, ".variants", variantName);
+  if (existsSync12(variantDir)) {
     return c.json({ error: `Variant directory already exists: ${variantDir}` }, 409);
   }
-  mkdirSync7(resolve15(projectRoot, ".variants"), { recursive: true });
+  mkdirSync8(resolve16(projectRoot, ".variants"), { recursive: true });
   try {
     await gitExec(["worktree", "add", "-b", variantName, variantDir], { cwd: projectRoot });
   } catch (e) {
@@ -5364,7 +5145,7 @@ var app23 = new Hono23().get("/:name/variants", async (c) => {
       const [cmd, args] = wrapForIsolation("npm", ["install"], mindName);
       await exec(cmd, args, {
         cwd: variantDir,
-        env: { ...process.env, HOME: resolve15(variantDir, "home") }
+        env: { ...process.env, HOME: resolve16(variantDir, "home") }
       });
     } else {
       await exec("npm", ["install"], { cwd: variantDir });
@@ -5374,7 +5155,7 @@ var app23 = new Hono23().get("/:name/variants", async (c) => {
     return c.json({ error: `npm install failed: ${msg}` }, 500);
   }
   if (body.soul) {
-    writeFileSync7(resolve15(variantDir, "home/SOUL.md"), body.soul);
+    writeFileSync8(resolve16(variantDir, "home/SOUL.md"), body.soul);
   }
   const variantPort = body.port ?? nextPort();
   const variant = {
@@ -5412,7 +5193,7 @@ var app23 = new Hono23().get("/:name/variants", async (c) => {
   } catch {
   }
   const projectRoot = mindDir(mindName);
-  if (existsSync11(variant.path)) {
+  if (existsSync12(variant.path)) {
     const status = (await gitExec(["status", "--porcelain"], { cwd: variant.path })).trim();
     if (status) {
       try {
@@ -5485,7 +5266,7 @@ var app23 = new Hono23().get("/:name/variants", async (c) => {
       const [cmd, args] = wrapForIsolation("npm", ["install"], mindName);
       await exec(cmd, args, {
         cwd: projectRoot,
-        env: { ...process.env, HOME: resolve15(projectRoot, "home") }
+        env: { ...process.env, HOME: resolve16(projectRoot, "home") }
       });
     } else {
       await exec("npm", ["install"], { cwd: projectRoot });
@@ -5612,8 +5393,8 @@ async function fanOutToMinds2(opts) {
   const participantNames = participants.map((p) => p.username);
   const isDM = opts.isDM ?? participants.length === 2;
   const channelEntryType = opts.channelEntryType ?? (isDM ? "dm" : "group");
-  const { getMindManager: getMindManager2 } = await import("./mind-manager-P5OBDUKI.js");
-  const { getSleepManagerIfReady } = await import("./sleep-manager-3RWUX2ZR.js");
+  const { getMindManager: getMindManager2 } = await import("./mind-manager-ZNRIYEK3.js");
+  const { getSleepManagerIfReady } = await import("./sleep-manager-XXSWQQLE.js");
   const manager = getMindManager2();
   const sm = getSleepManagerIfReady();
   const targetMinds = mindParticipants.map((ap) => {
@@ -5730,11 +5511,15 @@ var app25 = new Hono25().post("/:name/chat", zValidator9("json", chatSchema), as
     }
   }
   await addMessage(conversationId, "user", senderName, contentBlocks);
+  const isDM = conv?.type === "dm";
   await fanOutToMinds2({
     conversationId,
     contentBlocks,
     senderName,
     convTitle,
+    isDM,
+    channelEntryType: conv?.type === "channel" ? "group" : isDM ? "dm" : "group",
+    slugExtra: conv ? { convType: conv.type, convName: conv.name } : void 0,
     targetName: (username) => username === baseName ? name : username
   });
   return c.json({ ok: true, conversationId });
@@ -5745,7 +5530,7 @@ var app25 = new Hono25().post("/:name/chat", zValidator9("json", chatSchema), as
     return c.json({ error: "Conversation not found" }, 404);
   }
   return streamSSE6(c, async (stream) => {
-    const unsubscribe = subscribe2(conversationId, (event) => {
+    const unsubscribe = subscribe3(conversationId, (event) => {
       stream.writeSSE({ data: JSON.stringify(event) }).catch((err) => {
         if (!stream.aborted) console.error("[chat] SSE write error:", err);
       });
@@ -5755,11 +5540,11 @@ var app25 = new Hono25().post("/:name/chat", zValidator9("json", chatSchema), as
         if (!stream.aborted) console.error("[chat] SSE ping error:", err);
       });
     }, 15e3);
-    await new Promise((resolve18) => {
+    await new Promise((resolve19) => {
       stream.onAbort(() => {
         unsubscribe();
         clearInterval(keepAlive);
-        resolve18();
+        resolve19();
       });
     });
   });
@@ -5961,7 +5746,7 @@ var app27 = new Hono27().use("*", authMiddleware).get("/", async (c) => {
     return c.json({ error: "Conversation not found" }, 404);
   }
   return streamSSE7(c, async (stream) => {
-    const unsubscribe = subscribe2(conversationId, (event) => {
+    const unsubscribe = subscribe3(conversationId, (event) => {
       stream.writeSSE({ data: JSON.stringify(event) }).catch((err) => {
         if (!stream.aborted) console.error("[chat] SSE write error:", err);
       });
@@ -5971,11 +5756,11 @@ var app27 = new Hono27().use("*", authMiddleware).get("/", async (c) => {
         if (!stream.aborted) console.error("[chat] SSE ping error:", err);
       });
     }, 15e3);
-    await new Promise((resolve18) => {
+    await new Promise((resolve19) => {
       stream.onAbort(() => {
         unsubscribe();
         clearInterval(keepAlive);
-        resolve18();
+        resolve19();
       });
     });
   });
@@ -6073,13 +5858,14 @@ var MIME_TYPES2 = {
 };
 async function startServer({
   port,
-  hostname = "127.0.0.1"
+  hostname = "127.0.0.1",
+  tls
 }) {
   let assetsDir = "";
   let searchDir = dirname(new URL(import.meta.url).pathname);
   for (let i = 0; i < 5; i++) {
-    const candidate = resolve16(searchDir, "dist", "web-assets");
-    if (existsSync12(candidate)) {
+    const candidate = resolve17(searchDir, "dist", "web-assets");
+    if (existsSync13(candidate)) {
       assetsDir = candidate;
       break;
     }
@@ -6089,16 +5875,16 @@ async function startServer({
     app_default.get("*", async (c) => {
       const urlPath = new URL(c.req.url).pathname;
       if (urlPath.startsWith("/api/")) return c.notFound();
-      const filePath = resolve16(assetsDir, urlPath.slice(1));
+      const filePath = resolve17(assetsDir, urlPath.slice(1));
       if (!filePath.startsWith(assetsDir)) return c.text("Forbidden", 403);
       const s = await stat3(filePath).catch(() => null);
       if (s?.isFile()) {
-        const ext = extname3(filePath);
+        const ext = extname4(filePath);
         const mime = MIME_TYPES2[ext] || "application/octet-stream";
         const body = await readFile3(filePath);
         return c.body(body, 200, { "Content-Type": mime });
       }
-      const indexPath = resolve16(assetsDir, "index.html");
+      const indexPath = resolve17(assetsDir, "index.html");
       const indexStat = await stat3(indexPath).catch(() => null);
       if (indexStat?.isFile()) {
         const body = await readFile3(indexPath, "utf-8");
@@ -6107,22 +5893,55 @@ async function startServer({
       return c.text("Not found", 404);
     });
   }
+  if (tls) {
+    const server2 = serve({
+      fetch: app_default.fetch,
+      port,
+      hostname,
+      createServer: createHttpsServer,
+      serverOptions: { key: tls.key, cert: tls.cert }
+    });
+    await new Promise((resolve19, reject) => {
+      server2.on("listening", () => {
+        logger_default.info("Volute UI running (https)", { hostname, port });
+        resolve19();
+      });
+      server2.on("error", (err) => {
+        reject(err);
+      });
+    });
+    const internalPort = port + 1;
+    const internalServer = serve({ fetch: app_default.fetch, port: internalPort, hostname: "127.0.0.1" });
+    await new Promise((resolve19, reject) => {
+      internalServer.on("listening", () => {
+        logger_default.info("Volute API running (http, internal)", {
+          hostname: "127.0.0.1",
+          port: internalPort
+        });
+        resolve19();
+      });
+      internalServer.on("error", (err) => {
+        reject(err);
+      });
+    });
+    return { server: server2, internalPort };
+  }
   const server = serve({ fetch: app_default.fetch, port, hostname });
-  await new Promise((resolve18, reject) => {
+  await new Promise((resolve19, reject) => {
     server.on("listening", () => {
-      logger_default.info("Volute UI running", { hostname, port });
-      resolve18();
+      logger_default.info("Volute API running (http)", { hostname, port });
+      resolve19();
     });
     server.on("error", (err) => {
       reject(err);
     });
   });
-  return server;
+  return { server };
 }
 
 // src/daemon.ts
 if (!process.env.VOLUTE_HOME) {
-  process.env.VOLUTE_HOME = resolve17(homedir2(), ".volute");
+  process.env.VOLUTE_HOME = resolve18(homedir2(), ".volute");
 }
 if (process.env.VOLUTE_TIMEZONE && !process.env.TZ) {
   process.env.TZ = process.env.VOLUTE_TIMEZONE;
@@ -6132,7 +5951,7 @@ async function startDaemon(opts) {
   const myPid = String(process.pid);
   const home = voluteHome();
   if (!opts.foreground) {
-    const rotatingLog = new RotatingLog(resolve17(home, "daemon.log"));
+    const rotatingLog = new RotatingLog(resolve18(home, "daemon.log"));
     logger_default.setOutput((line) => rotatingLog.write(`${line}
 `));
     const write = (...args) => rotatingLog.write(`${format(...args)}
@@ -6142,9 +5961,9 @@ async function startDaemon(opts) {
     console.warn = write;
     console.info = write;
   }
-  const DAEMON_PID_PATH = resolve17(home, "daemon.pid");
-  const DAEMON_JSON_PATH = resolve17(home, "daemon.json");
-  mkdirSync8(home, { recursive: true });
+  const DAEMON_PID_PATH = resolve18(home, "daemon.pid");
+  const DAEMON_JSON_PATH = resolve18(home, "daemon.json");
+  mkdirSync9(home, { recursive: true });
   migrateAgentsToMinds();
   try {
     await ensureSharedRepo();
@@ -6158,12 +5977,16 @@ async function startDaemon(opts) {
     logger_default.error("failed to sync built-in skills", logger_default.errorData(err));
   }
   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;
-  let server;
+  let tls;
+  if (opts.tailscale) {
+    const { getTailscaleTls } = await import("./tailscale-AJ4VL5XK.js");
+    const tlsConfig = await getTailscaleTls();
+    tls = { key: tlsConfig.key, cert: tlsConfig.cert };
+    logger_default.info("Tailscale HTTPS enabled", { hostname: tlsConfig.hostname });
+  }
+  let result;
   try {
-    server = await startServer({ port, hostname });
+    result = await startServer({ port, hostname: "0.0.0.0", tls });
   } catch (err) {
     const e = err;
     if (e.code === "EADDRINUSE") {
@@ -6172,11 +5995,17 @@ async function startDaemon(opts) {
     }
     throw err;
   }
-  writeFileSync8(DAEMON_PID_PATH, myPid, { mode: 420 });
-  writeFileSync8(DAEMON_JSON_PATH, `${JSON.stringify({ port, hostname, token }, null, 2)}
-`, {
-    mode: 420
-  });
+  const { server, internalPort } = result;
+  const daemonPort = internalPort ?? port;
+  process.env.VOLUTE_DAEMON_TOKEN = token;
+  process.env.VOLUTE_DAEMON_PORT = String(daemonPort);
+  process.env.VOLUTE_DAEMON_HOSTNAME = hostname;
+  writeFileSync9(DAEMON_PID_PATH, myPid, { mode: 420 });
+  const daemonConfig = { port, hostname, token };
+  if (internalPort) daemonConfig.internalPort = internalPort;
+  if (tls) daemonConfig.tls = true;
+  writeFileSync9(DAEMON_JSON_PATH, `${JSON.stringify(daemonConfig, null, 2)}
+`, { mode: 420 });
   const delivery = initDeliveryManager();
   const manager = initMindManager();
   manager.loadCrashAttempts();
@@ -6208,8 +6037,8 @@ async function startDaemon(opts) {
         if (sleepManager.isSleeping(entry.name)) {
           try {
             const dir = mindDir(entry.name);
-            const daemonPort = process.env.VOLUTE_DAEMON_PORT ? parseInt(process.env.VOLUTE_DAEMON_PORT, 10) : void 0;
-            await connectors.startConnectors(entry.name, dir, entry.port, daemonPort);
+            const daemonPort2 = process.env.VOLUTE_DAEMON_PORT ? parseInt(process.env.VOLUTE_DAEMON_PORT, 10) : void 0;
+            await connectors.startConnectors(entry.name, dir, entry.port, daemonPort2);
             scheduler.loadSchedules(entry.name);
           } catch (err) {
             logger_default.error(
@@ -6246,7 +6075,7 @@ async function startDaemon(opts) {
     });
     await Promise.all(workers);
   }
-  import("./cloud-sync-C6WRYRVR.js").then(
+  import("./cloud-sync-DIU3OCPV.js").then(
     ({ consumeQueuedMessages }) => consumeQueuedMessages().catch((err) => {
       logger_default.warn("failed to consume queued cloud messages", logger_default.errorData(err));
     })
@@ -6254,7 +6083,7 @@ async function startDaemon(opts) {
     logger_default.warn("failed to load cloud-sync module", logger_default.errorData(err));
   });
   try {
-    const { backfillTemplateHashes, notifyVersionUpdate } = await import("./version-notify-5FGUAVSF.js");
+    const { backfillTemplateHashes, notifyVersionUpdate } = await import("./version-notify-SZ75QRGO.js");
     backfillTemplateHashes();
     notifyVersionUpdate().catch((err) => {
       logger_default.warn("failed to send version update notifications", logger_default.errorData(err));
@@ -6271,13 +6100,13 @@ async function startDaemon(opts) {
   logger_default.info(`running on ${hostname}:${port}, pid ${myPid}`);
   function cleanup() {
     try {
-      if (readFileSync10(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
+      if (readFileSync11(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
         unlinkSync(DAEMON_PID_PATH);
       }
     } catch {
     }
     try {
-      const data = JSON.parse(readFileSync10(DAEMON_JSON_PATH, "utf-8"));
+      const data = JSON.parse(readFileSync11(DAEMON_JSON_PATH, "utf-8"));
       if (data.token === token) {
         unlinkSync(DAEMON_JSON_PATH);
       }
@@ -6291,9 +6120,9 @@ async function startDaemon(opts) {
     logger_default.info("shutting down...");
     const safe = (label, fn) => {
       try {
-        const result = fn();
-        if (result instanceof Promise)
-          return result.catch((err) => logger_default.error(`shutdown: ${label} failed`, logger_default.errorData(err)));
+        const result2 = fn();
+        if (result2 instanceof Promise)
+          return result2.catch((err) => logger_default.error(`shutdown: ${label} failed`, logger_default.errorData(err)));
       } catch (err) {
         logger_default.error(`shutdown: ${label} failed`, logger_default.errorData(err));
       }
@@ -6325,9 +6154,10 @@ async function startDaemon(opts) {
   process.on("exit", cleanup);
 }
 if (import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith("daemon.ts")) {
-  let port = 4200;
+  let port = 1618;
   let hostname = "127.0.0.1";
   let foreground = false;
+  let tailscale = false;
   for (let i = 2; i < process.argv.length; i++) {
     if (process.argv[i] === "--port" && process.argv[i + 1]) {
       port = parseInt(process.argv[i + 1], 10);
@@ -6337,9 +6167,11 @@ if (import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith
       i++;
     } else if (process.argv[i] === "--foreground") {
       foreground = true;
+    } else if (process.argv[i] === "--tailscale") {
+      tailscale = true;
     }
   }
-  startDaemon({ port, hostname, foreground });
+  startDaemon({ port, hostname, foreground, tailscale });
 }
 export {
   startDaemon