volute 0.17.0 → 0.18.0

package/dist/daemon.js

@@ -10,15 +10,30 @@ import {
   readSystemsConfig
 } from "./chunk-37X7ECMF.js";
 import {
+  PROMPT_DEFAULTS,
+  PROMPT_KEYS,
   RotatingLog,
   clearJsonMap,
+  conversationParticipants,
+  conversations,
+  getDb,
   getMindManager,
+  getMindPromptDefaults,
+  getPrompt,
+  getPromptIfCustom,
   initMindManager,
   loadJsonMap,
   logBuffer,
   logger_default,
-  saveJsonMap
-} from "./chunk-CE7WMOVW.js";
+  messages,
+  mindHistory,
+  saveJsonMap,
+  sessions,
+  sharedSkills,
+  substitute,
+  systemPrompts,
+  users
+} from "./chunk-AYB7XAWO.js";
 import {
   findOpenClawSession,
   importOpenClawConnectors,
@@ -37,7 +52,7 @@ import {
 import {
   CHANNELS,
   getChannelDriver
-} from "./chunk-MIJIAGGG.js";
+} from "./chunk-FW5API7X.js";
 import {
   exec,
   gitExec,
@@ -60,7 +75,7 @@ import "./chunk-D424ZQGI.js";
 import {
   buildVoluteSlug,
   writeChannelEntry
-} from "./chunk-3FC42ZBM.js";
+} from "./chunk-GK4E7LM7.js";
 import {
   addMind,
   addVariant,
@@ -85,15 +100,13 @@ import {
   validateMindName,
   voluteHome
 } from "./chunk-M77QBTEH.js";
-import {
-  __export
-} from "./chunk-K3NQKI34.js";
+import "./chunk-K3NQKI34.js";
 
 // src/daemon.ts
 import { randomBytes } from "crypto";
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync9, unlinkSync as unlinkSync2, writeFileSync as writeFileSync7 } from "fs";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync10, unlinkSync as unlinkSync2, writeFileSync as writeFileSync8 } 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/connector-manager.ts
@@ -343,19 +356,19 @@ var ConnectorManager = class {
     const stopKey = `${mindName}:${type}`;
     this.stopping.add(stopKey);
     mindMap.delete(type);
-    await new Promise((resolve18) => {
-      tracked.child.on("exit", () => resolve18());
+    await new Promise((resolve19) => {
+      tracked.child.on("exit", () => resolve19());
       try {
         tracked.child.kill("SIGTERM");
       } catch {
-        resolve18();
+        resolve19();
       }
       setTimeout(() => {
         try {
           tracked.child.kill("SIGKILL");
         } catch {
         }
-        resolve18();
+        resolve19();
       }, 5e3);
     });
     this.stopping.delete(stopKey);
@@ -632,9 +645,9 @@ var MailPoller = class {
     }
     const channel = `mail:${email.from.address}`;
     const sender = email.from.name || email.from.address;
-    const text2 = formatEmailContent(email);
+    const text = formatEmailContent(email);
     const body = JSON.stringify({
-      content: [{ type: "text", text: text2 }],
+      content: [{ type: "text", text }],
       channel,
       sender,
       platform: "Email",
@@ -1164,129 +1177,12 @@ import { createMiddleware } from "hono/factory";
 // src/lib/auth.ts
 import { compareSync, hashSync } from "bcryptjs";
 import { and, count, eq } from "drizzle-orm";
-
-// src/lib/db.ts
-import { chmodSync, existsSync as existsSync5 } from "fs";
-import { dirname as dirname2, resolve as resolve6 } from "path";
-import { fileURLToPath } from "url";
-import { drizzle } from "drizzle-orm/libsql";
-import { migrate } from "drizzle-orm/libsql/migrator";
-
-// src/lib/schema.ts
-var schema_exports = {};
-__export(schema_exports, {
-  conversationParticipants: () => conversationParticipants,
-  conversations: () => conversations,
-  messages: () => messages,
-  mindHistory: () => mindHistory,
-  sessions: () => sessions,
-  users: () => users
-});
-import { sql } from "drizzle-orm";
-import { index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
-var users = sqliteTable("users", {
-  id: integer("id").primaryKey({ autoIncrement: true }),
-  username: text("username").unique().notNull(),
-  password_hash: text("password_hash").notNull(),
-  role: text("role").notNull().default("pending"),
-  user_type: text("user_type").notNull().default("human"),
-  created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
-});
-var conversations = sqliteTable(
-  "conversations",
-  {
-    id: text("id").primaryKey(),
-    mind_name: text("mind_name").notNull(),
-    channel: text("channel").notNull(),
-    user_id: integer("user_id").references(() => users.id),
-    title: text("title"),
-    created_at: text("created_at").notNull().default(sql`(datetime('now'))`),
-    updated_at: text("updated_at").notNull().default(sql`(datetime('now'))`)
-  },
-  (table) => [
-    index("idx_conversations_mind_name").on(table.mind_name),
-    index("idx_conversations_user_id").on(table.user_id),
-    index("idx_conversations_updated_at").on(table.updated_at)
-  ]
-);
-var mindHistory = sqliteTable(
-  "mind_history",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    mind: text("mind").notNull(),
-    channel: text("channel"),
-    session: text("session"),
-    sender: text("sender"),
-    message_id: text("message_id"),
-    type: text("type").notNull(),
-    content: text("content"),
-    metadata: text("metadata"),
-    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
-  },
-  (table) => [
-    index("idx_mind_history_mind").on(table.mind),
-    index("idx_mind_history_mind_channel").on(table.mind, table.channel),
-    index("idx_mind_history_mind_type").on(table.mind, table.type)
-  ]
-);
-var conversationParticipants = sqliteTable(
-  "conversation_participants",
-  {
-    conversation_id: text("conversation_id").notNull().references(() => conversations.id, { onDelete: "cascade" }),
-    user_id: integer("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    role: text("role").notNull().default("member"),
-    joined_at: text("joined_at").notNull().default(sql`(datetime('now'))`)
-  },
-  (table) => [
-    uniqueIndex("idx_cp_unique").on(table.conversation_id, table.user_id),
-    index("idx_cp_user_id").on(table.user_id)
-  ]
-);
-var sessions = sqliteTable("sessions", {
-  id: text("id").primaryKey(),
-  userId: integer("user_id").references(() => users.id, { onDelete: "cascade" }).notNull(),
-  createdAt: integer("created_at").notNull()
-});
-var messages = sqliteTable(
-  "messages",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    conversation_id: text("conversation_id").notNull().references(() => conversations.id, { onDelete: "cascade" }),
-    role: text("role").notNull(),
-    sender_name: text("sender_name"),
-    content: text("content").notNull(),
-    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
-  },
-  (table) => [index("idx_messages_conversation_id").on(table.conversation_id)]
-);
-
-// src/lib/db.ts
-var __dirname = dirname2(fileURLToPath(import.meta.url));
-var migrationsFolder = existsSync5(resolve6(__dirname, "../drizzle")) ? resolve6(__dirname, "../drizzle") : resolve6(__dirname, "../../drizzle");
-var db = null;
-async function getDb() {
-  if (db) return db;
-  const dbPath = process.env.VOLUTE_DB_PATH || resolve6(voluteHome(), "volute.db");
-  db = drizzle({ connection: { url: `file:${dbPath}` }, schema: schema_exports });
-  await migrate(db, { migrationsFolder });
-  try {
-    chmodSync(dbPath, 384);
-  } catch (err) {
-    console.error(
-      `[volute] WARNING: Failed to restrict database file permissions on ${dbPath}:`,
-      err
-    );
-  }
-  return db;
-}
-
-// src/lib/auth.ts
 async function createUser(username, password) {
-  const db2 = await getDb();
+  const db = await getDb();
   const hash = hashSync(password, 10);
-  const [{ value }] = await db2.select({ value: count() }).from(users).where(eq(users.user_type, "human"));
+  const [{ value }] = await db.select({ value: count() }).from(users).where(eq(users.user_type, "human"));
   const role = value === 0 ? "admin" : "pending";
-  const [result] = await db2.insert(users).values({ username, password_hash: hash, role }).returning({
+  const [result] = await db.insert(users).values({ username, password_hash: hash, role }).returning({
     id: users.id,
     username: users.username,
     role: users.role,
@@ -1296,8 +1192,8 @@ async function createUser(username, password) {
   return result;
 }
 async function verifyUser(username, password) {
-  const db2 = await getDb();
-  const row = await db2.select().from(users).where(eq(users.username, username)).get();
+  const db = await getDb();
+  const row = await db.select().from(users).where(eq(users.username, username)).get();
   if (!row) return null;
   if (row.user_type === "mind") return null;
   if (!compareSync(password, row.password_hash)) return null;
@@ -1305,8 +1201,8 @@ async function verifyUser(username, password) {
   return user;
 }
 async function getUser(id) {
-  const db2 = await getDb();
-  const row = await db2.select({
+  const db = await getDb();
+  const row = await db.select({
     id: users.id,
     username: users.username,
     role: users.role,
@@ -1316,8 +1212,8 @@ async function getUser(id) {
   return row ?? null;
 }
 async function getUserByUsername(username) {
-  const db2 = await getDb();
-  const row = await db2.select({
+  const db = await getDb();
+  const row = await db.select({
     id: users.id,
     username: users.username,
     role: users.role,
@@ -1327,8 +1223,8 @@ async function getUserByUsername(username) {
   return row ?? null;
 }
 async function listUsers() {
-  const db2 = await getDb();
-  return db2.select({
+  const db = await getDb();
+  return db.select({
     id: users.id,
     username: users.username,
     role: users.role,
@@ -1337,8 +1233,8 @@ async function listUsers() {
   }).from(users).orderBy(users.created_at).all();
 }
 async function listPendingUsers() {
-  const db2 = await getDb();
-  return db2.select({
+  const db = await getDb();
+  return db.select({
     id: users.id,
     username: users.username,
     role: users.role,
@@ -1347,8 +1243,8 @@ async function listPendingUsers() {
   }).from(users).where(eq(users.role, "pending")).orderBy(users.created_at).all();
 }
 async function listUsersByType(userType) {
-  const db2 = await getDb();
-  return db2.select({
+  const db = await getDb();
+  return db.select({
     id: users.id,
     username: users.username,
     role: users.role,
@@ -1357,8 +1253,8 @@ async function listUsersByType(userType) {
   }).from(users).where(eq(users.user_type, userType)).orderBy(users.created_at).all();
 }
 async function getOrCreateMindUser(mindName) {
-  const db2 = await getDb();
-  const existing = await db2.select({
+  const db = await getDb();
+  const existing = await db.select({
     id: users.id,
     username: users.username,
     role: users.role,
@@ -1367,7 +1263,7 @@ async function getOrCreateMindUser(mindName) {
   }).from(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind"))).get();
   if (existing) return existing;
   try {
-    const [result] = await db2.insert(users).values({
+    const [result] = await db.insert(users).values({
       username: mindName,
       password_hash: "!mind",
       role: "mind",
@@ -1382,7 +1278,7 @@ async function getOrCreateMindUser(mindName) {
     return result;
   } catch (err) {
     if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
-      const retried = await db2.select({
+      const retried = await db.select({
         id: users.id,
         username: users.username,
         role: users.role,
@@ -1395,12 +1291,21 @@ async function getOrCreateMindUser(mindName) {
   }
 }
 async function deleteMindUser2(mindName) {
-  const db2 = await getDb();
-  await db2.delete(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind")));
+  const db = await getDb();
+  await db.delete(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind")));
+}
+async function changePassword(userId, currentPassword, newPassword) {
+  const db = await getDb();
+  const row = await db.select().from(users).where(eq(users.id, userId)).get();
+  if (!row) return false;
+  if (!compareSync(currentPassword, row.password_hash)) return false;
+  const hash = hashSync(newPassword, 10);
+  await db.update(users).set({ password_hash: hash }).where(eq(users.id, userId));
+  return true;
 }
 async function approveUser(id) {
-  const db2 = await getDb();
-  await db2.update(users).set({ role: "user" }).where(and(eq(users.id, id), eq(users.role, "pending")));
+  const db = await getDb();
+  await db.update(users).set({ role: "user" }).where(and(eq(users.id, id), eq(users.role, "pending")));
 }
 
 // src/web/middleware/auth.ts
@@ -1411,29 +1316,29 @@ function isValidDaemonToken(token) {
 }
 var SESSION_MAX_AGE = 864e5;
 async function createSession(userId) {
-  const db2 = await getDb();
+  const db = await getDb();
   const sessionId = crypto.randomUUID();
-  await db2.insert(sessions).values({ id: sessionId, userId, createdAt: Date.now() });
+  await db.insert(sessions).values({ id: sessionId, userId, createdAt: Date.now() });
   return sessionId;
 }
 async function deleteSession(sessionId) {
-  const db2 = await getDb();
-  await db2.delete(sessions).where(eq2(sessions.id, sessionId));
+  const db = await getDb();
+  await db.delete(sessions).where(eq2(sessions.id, sessionId));
 }
 async function getSessionUserId(sessionId) {
-  const db2 = await getDb();
-  const row = await db2.select().from(sessions).where(eq2(sessions.id, sessionId)).get();
+  const db = await getDb();
+  const row = await db.select().from(sessions).where(eq2(sessions.id, sessionId)).get();
   if (!row) return void 0;
   if (Date.now() - row.createdAt > SESSION_MAX_AGE) {
-    await db2.delete(sessions).where(eq2(sessions.id, sessionId));
+    await db.delete(sessions).where(eq2(sessions.id, sessionId));
     return void 0;
   }
   return row.userId;
 }
 async function cleanExpiredSessions() {
-  const db2 = await getDb();
+  const db = await getDb();
   const cutoff = Date.now() - SESSION_MAX_AGE;
-  await db2.delete(sessions).where(lt(sessions.createdAt, cutoff));
+  await db.delete(sessions).where(lt(sessions.createdAt, cutoff));
 }
 var requireAdmin = createMiddleware(async (c, next) => {
   const user = c.get("user");
@@ -1464,13 +1369,13 @@ var authMiddleware = createMiddleware(async (c, next) => {
 });
 
 // src/web/server.ts
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import { readFile as readFile3, stat as stat2 } from "fs/promises";
-import { dirname as dirname3, extname as extname2, resolve as resolve16 } from "path";
+import { dirname as dirname2, extname as extname2, resolve as resolve17 } from "path";
 import { serve } from "@hono/node-server";
 
 // src/web/app.ts
-import { Hono as Hono17 } from "hono";
+import { Hono as Hono21 } from "hono";
 import { bodyLimit } from "hono/body-limit";
 import { csrf } from "hono/csrf";
 import { HTTPException } from "hono/http-exception";
@@ -1484,6 +1389,17 @@ var credentialsSchema = z.object({
   username: z.string().min(1),
   password: z.string().min(1)
 });
+var changePasswordSchema = z.object({
+  currentPassword: z.string().min(1),
+  newPassword: z.string().min(1)
+});
+var authenticated = new Hono().use(authMiddleware).post("/change-password", zValidator("json", changePasswordSchema), async (c) => {
+  const user = c.get("user");
+  const { currentPassword, newPassword } = c.req.valid("json");
+  const ok = await changePassword(user.id, currentPassword, newPassword);
+  if (!ok) return c.json({ error: "Current password is incorrect" }, 400);
+  return c.json({ ok: true });
+});
 var admin = new Hono().use(authMiddleware).get("/users", async (c) => {
   const user = c.get("user");
   if (user.role !== "admin") return c.json({ error: "Forbidden" }, 403);
@@ -1543,7 +1459,7 @@ var app = new Hono().post("/register", zValidator("json", credentialsSchema), as
   const user = await getUser(userId);
   if (!user) return c.json({ error: "Not logged in" }, 401);
   return c.json({ id: user.id, username: user.username, role: user.role });
-}).route("/", admin);
+}).route("/", admin).route("/", authenticated);
 var auth_default = app;
 
 // src/web/api/channels.ts
@@ -1797,9 +1713,9 @@ var sharedEnvApp = new Hono4().get("/", (c) => {
 var env_default = app4;
 
 // src/web/api/files.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { readdir, readFile } from "fs/promises";
-import { resolve as resolve7 } from "path";
+import { resolve as resolve6 } from "path";
 import { Hono as Hono5 } from "hono";
 var ALLOWED_FILES = /* @__PURE__ */ new Set(["SOUL.md", "MEMORY.md", "CLAUDE.md", "VOLUTE.md"]);
 var app5 = new Hono5().get("/:name/files", async (c) => {
@@ -1807,8 +1723,8 @@ var app5 = new Hono5().get("/:name/files", async (c) => {
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const dir = mindDir(name);
-  const homeDir = resolve7(dir, "home");
-  if (!existsSync6(homeDir)) return c.json({ error: "Home directory missing" }, 404);
+  const homeDir = resolve6(dir, "home");
+  if (!existsSync5(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);
@@ -1821,8 +1737,8 @@ var app5 = new Hono5().get("/:name/files", async (c) => {
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const dir = mindDir(name);
-  const filePath = resolve7(dir, "home", filename);
-  if (!existsSync6(filePath)) {
+  const filePath = resolve6(dir, "home", filename);
+  if (!existsSync5(filePath)) {
     return c.json({ error: "File not found" }, 404);
   }
   const content = await readFile(filePath, "utf-8");
@@ -1832,16 +1748,16 @@ var files_default = app5;
 
 // src/web/api/logs.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync7 } from "fs";
-import { resolve as resolve8 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { resolve as resolve7 } from "path";
 import { Hono as Hono6 } from "hono";
 import { streamSSE } from "hono/streaming";
 var app6 = new Hono6().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 = resolve7(stateDir(name), "logs", "mind.log");
+  if (!existsSync6(logFile)) {
     return c.json({ error: "No log file found" }, 404);
   }
   return streamSSE(c, async (stream) => {
@@ -1859,17 +1775,17 @@ var app6 = new Hono6().get("/:name/logs", async (c) => {
     stream.onAbort(() => {
       tail.kill();
     });
-    await new Promise((resolve18) => {
-      tail.on("exit", resolve18);
-      stream.onAbort(resolve18);
+    await new Promise((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 = resolve7(stateDir(name), "logs", "mind.log");
+  if (!existsSync6(logFile)) {
     return c.json({ error: "No log file found" }, 404);
   }
   const nParam = parseInt(c.req.query("n") ?? "50", 10);
@@ -1879,44 +1795,421 @@ var app6 = new Hono6().get("/:name/logs", async (c) => {
   tail.stdout.on("data", (data) => {
     output += data.toString();
   });
-  await new Promise((resolve18) => {
-    tail.on("exit", resolve18);
+  await new Promise((resolve19) => {
+    tail.on("exit", resolve19);
   });
   return c.text(output);
 });
 var logs_default = app6;
 
-// src/web/api/minds.ts
+// src/web/api/mind-skills.ts
+import { zValidator as zValidator2 } from "@hono/zod-validator";
+import { Hono as Hono7 } from "hono";
+import { z as z2 } from "zod";
+
+// src/lib/skills.ts
 import {
   cpSync,
-  existsSync as existsSync8,
-  mkdirSync as mkdirSync4,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync6,
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync4,
   rmSync,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { tmpdir } from "os";
+import { basename, join, resolve as resolve8 } from "path";
+import { eq as eq3, sql } from "drizzle-orm";
+var VALID_SKILL_ID = /^[a-zA-Z0-9_-]+$/;
+function validateSkillId(id) {
+  if (!id || !VALID_SKILL_ID.test(id)) {
+    throw new Error(`Invalid skill ID: ${id}`);
+  }
+}
+function sharedSkillsDir() {
+  return resolve8(voluteHome(), "skills");
+}
+function parseSkillMd(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return { name: "", description: "" };
+  const frontmatter = match[1];
+  const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
+  const descMatch = frontmatter.match(/^description:\s*(.+)$/m);
+  return {
+    name: nameMatch?.[1].trim() ?? "",
+    description: descMatch?.[1].trim() ?? ""
+  };
+}
+async function listSharedSkills() {
+  const db = await getDb();
+  return db.select().from(sharedSkills).all();
+}
+async function getSharedSkill(id) {
+  const db = await getDb();
+  return db.select().from(sharedSkills).where(eq3(sharedSkills.id, id)).get();
+}
+async function importSkillFromDir(sourceDir, author) {
+  const skillMdPath = join(sourceDir, "SKILL.md");
+  if (!existsSync7(skillMdPath)) {
+    throw new Error("SKILL.md not found in source directory");
+  }
+  const content = readFileSync4(skillMdPath, "utf-8");
+  const { name, description } = parseSkillMd(content);
+  const id = basename(sourceDir);
+  if (!id || id === "." || id === "..") {
+    throw new Error("Invalid skill directory name");
+  }
+  validateSkillId(id);
+  const destDir = join(sharedSkillsDir(), id);
+  if (existsSync7(destDir)) rmSync(destDir, { recursive: true });
+  mkdirSync3(destDir, { recursive: true });
+  cpSync(sourceDir, destDir, { recursive: true });
+  const upstreamPath = join(destDir, ".upstream.json");
+  if (existsSync7(upstreamPath)) rmSync(upstreamPath);
+  const db = await getDb();
+  const existing = await db.select().from(sharedSkills).where(eq3(sharedSkills.id, id)).get();
+  const version = existing ? existing.version + 1 : 1;
+  await db.insert(sharedSkills).values({ id, name: name || id, description, author, version }).onConflictDoUpdate({
+    target: sharedSkills.id,
+    set: {
+      name: name || id,
+      description,
+      author,
+      version,
+      updated_at: sql`(datetime('now'))`
+    }
+  });
+  const row = await db.select().from(sharedSkills).where(eq3(sharedSkills.id, id)).get();
+  if (!row) throw new Error(`Failed to upsert shared skill: ${id}`);
+  return row;
+}
+async function removeSharedSkill(id) {
+  const db = await getDb();
+  const existing = await db.select().from(sharedSkills).where(eq3(sharedSkills.id, id)).get();
+  if (!existing) throw new Error(`Shared skill not found: ${id}`);
+  await db.delete(sharedSkills).where(eq3(sharedSkills.id, id));
+  const dir = join(sharedSkillsDir(), id);
+  if (existsSync7(dir)) rmSync(dir, { recursive: true });
+}
+function mindSkillsDir(dir) {
+  return resolve8(dir, "home", ".claude", "skills");
+}
+function readUpstream(skillDir) {
+  const upstreamPath = join(skillDir, ".upstream.json");
+  if (!existsSync7(upstreamPath)) return null;
+  try {
+    const data = JSON.parse(readFileSync4(upstreamPath, "utf-8"));
+    if (typeof data?.source !== "string" || typeof data?.version !== "number" || typeof data?.baseCommit !== "string") {
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+async function installSkill(_mindName, dir, skillId) {
+  validateSkillId(skillId);
+  const shared = await getSharedSkill(skillId);
+  if (!shared) throw new Error(`Shared skill not found: ${skillId}`);
+  const sourceDir = join(sharedSkillsDir(), skillId);
+  if (!existsSync7(sourceDir)) throw new Error(`Shared skill files not found: ${skillId}`);
+  const destDir = join(mindSkillsDir(dir), skillId);
+  if (existsSync7(destDir)) throw new Error(`Skill already installed: ${skillId}`);
+  mkdirSync3(destDir, { recursive: true });
+  cpSync(sourceDir, destDir, { recursive: true });
+  await gitExec(["add", join("home", ".claude", "skills", skillId)], { cwd: dir });
+  await gitExec(["commit", "-m", `Install shared skill: ${skillId}`], { cwd: dir });
+  const commitHash = (await gitExec(["rev-parse", "HEAD"], { cwd: dir })).trim();
+  const upstream = {
+    source: skillId,
+    version: shared.version,
+    baseCommit: commitHash
+  };
+  writeFileSync3(join(destDir, ".upstream.json"), `${JSON.stringify(upstream, null, 2)}
+`);
+  await gitExec(["add", join("home", ".claude", "skills", skillId, ".upstream.json")], {
+    cwd: dir
+  });
+  await gitExec(["commit", "--amend", "--no-edit"], { cwd: dir });
+}
+async function uninstallSkill(_mindName, dir, skillId) {
+  validateSkillId(skillId);
+  const skillDir = join(mindSkillsDir(dir), skillId);
+  if (!existsSync7(skillDir)) throw new Error(`Skill not installed: ${skillId}`);
+  rmSync(skillDir, { recursive: true });
+  await gitExec(["add", join("home", ".claude", "skills", skillId)], { cwd: dir });
+  await gitExec(["commit", "-m", `Uninstall skill: ${skillId}`], { cwd: dir });
+}
+async function updateSkill(_mindName, dir, skillId) {
+  validateSkillId(skillId);
+  const skillDir = join(mindSkillsDir(dir), skillId);
+  if (!existsSync7(skillDir)) throw new Error(`Skill not installed: ${skillId}`);
+  const upstream = readUpstream(skillDir);
+  if (!upstream) throw new Error(`No upstream tracking for skill: ${skillId}`);
+  const shared = await getSharedSkill(upstream.source);
+  if (!shared) throw new Error(`Shared skill no longer exists: ${upstream.source}`);
+  if (shared.version <= upstream.version) {
+    return { status: "up-to-date" };
+  }
+  const sourceDir = join(sharedSkillsDir(), upstream.source);
+  if (!existsSync7(sourceDir)) throw new Error(`Shared skill files missing: ${upstream.source}`);
+  const relSkillPath = join("home", ".claude", "skills", skillId);
+  const currentFiles = listFilesRecursive(skillDir).filter((f) => f !== ".upstream.json");
+  const newFiles = listFilesRecursive(sourceDir).filter((f) => f !== ".upstream.json");
+  const allFiles = [.../* @__PURE__ */ new Set([...currentFiles, ...newFiles])];
+  const conflictFiles = [];
+  const tmpBase = join(tmpdir(), `volute-merge-${process.pid}-${Date.now()}`);
+  mkdirSync3(tmpBase, { recursive: true });
+  try {
+    for (const file of allFiles) {
+      const currentPath = join(skillDir, file);
+      const newPath = join(sourceDir, file);
+      const currentExists = existsSync7(currentPath);
+      const newExists = existsSync7(newPath);
+      if (!currentExists && newExists) {
+        const destPath = join(skillDir, file);
+        mkdirSync3(join(skillDir, ...file.split("/").slice(0, -1)), { recursive: true });
+        cpSync(newPath, destPath);
+        continue;
+      }
+      if (currentExists && !newExists) {
+        let baseContent2 = null;
+        try {
+          baseContent2 = await gitExec(
+            ["show", `${upstream.baseCommit}:${join(relSkillPath, file)}`],
+            { cwd: dir }
+          );
+        } catch {
+          continue;
+        }
+        const currentContent2 = readFileSync4(currentPath, "utf-8");
+        if (currentContent2 === baseContent2) {
+          rmSync(currentPath);
+        }
+        continue;
+      }
+      let baseContent;
+      try {
+        baseContent = await gitExec(
+          ["show", `${upstream.baseCommit}:${join(relSkillPath, file)}`],
+          { cwd: dir }
+        );
+      } catch {
+        baseContent = "";
+      }
+      const currentContent = readFileSync4(currentPath, "utf-8");
+      const newContent = readFileSync4(newPath, "utf-8");
+      if (currentContent === baseContent) {
+        writeFileSync3(currentPath, newContent);
+        continue;
+      }
+      if (newContent === baseContent) {
+        continue;
+      }
+      const baseTmp = join(tmpBase, `${file}.base`);
+      const currentTmp = join(tmpBase, `${file}.current`);
+      const newTmp = join(tmpBase, `${file}.new`);
+      mkdirSync3(join(tmpBase, ...file.split("/").slice(0, -1)), { recursive: true });
+      writeFileSync3(baseTmp, baseContent);
+      writeFileSync3(currentTmp, currentContent);
+      writeFileSync3(newTmp, newContent);
+      try {
+        await exec("git", ["merge-file", currentTmp, baseTmp, newTmp]);
+        writeFileSync3(currentPath, readFileSync4(currentTmp, "utf-8"));
+      } catch (e) {
+        const exitCode = e && typeof e === "object" && "code" in e ? e.code : null;
+        if (exitCode === 1) {
+          writeFileSync3(currentPath, readFileSync4(currentTmp, "utf-8"));
+          conflictFiles.push(file);
+        } else {
+          throw e;
+        }
+      }
+    }
+  } finally {
+    rmSync(tmpBase, { recursive: true, force: true });
+  }
+  if (conflictFiles.length > 0) {
+    return { status: "conflict", conflictFiles };
+  }
+  const upstreamInfo = {
+    source: upstream.source,
+    version: shared.version,
+    baseCommit: upstream.baseCommit
+    // will update after commit
+  };
+  writeFileSync3(join(skillDir, ".upstream.json"), `${JSON.stringify(upstreamInfo, null, 2)}
+`);
+  await gitExec(["add", relSkillPath], { cwd: dir });
+  await gitExec(["commit", "-m", `Update skill: ${skillId} (v${shared.version})`], { cwd: dir });
+  const commitHash = (await gitExec(["rev-parse", "HEAD"], { cwd: dir })).trim();
+  upstreamInfo.baseCommit = commitHash;
+  writeFileSync3(join(skillDir, ".upstream.json"), `${JSON.stringify(upstreamInfo, null, 2)}
+`);
+  await gitExec(["add", join(relSkillPath, ".upstream.json")], { cwd: dir });
+  await gitExec(["commit", "--amend", "--no-edit"], { cwd: dir });
+  return { status: "updated" };
+}
+async function listMindSkills(dir) {
+  const skillsDir = mindSkillsDir(dir);
+  if (!existsSync7(skillsDir)) return [];
+  const entries = readdirSync2(skillsDir, { withFileTypes: true }).filter((e) => e.isDirectory());
+  const sharedMap = /* @__PURE__ */ new Map();
+  for (const s of await listSharedSkills()) {
+    sharedMap.set(s.id, s);
+  }
+  const results = [];
+  for (const entry of entries) {
+    const skillDir = join(skillsDir, entry.name);
+    const skillMdPath = join(skillDir, "SKILL.md");
+    let name = entry.name;
+    let description = "";
+    if (existsSync7(skillMdPath)) {
+      const parsed = parseSkillMd(readFileSync4(skillMdPath, "utf-8"));
+      if (parsed.name) name = parsed.name;
+      description = parsed.description;
+    }
+    const upstream = readUpstream(skillDir);
+    let updateAvailable = false;
+    if (upstream) {
+      const shared = sharedMap.get(upstream.source);
+      if (shared && shared.version > upstream.version) {
+        updateAvailable = true;
+      }
+    }
+    results.push({ id: entry.name, name, description, upstream, updateAvailable });
+  }
+  return results;
+}
+async function publishSkill(mindName, dir, skillId) {
+  const skillDir = join(mindSkillsDir(dir), skillId);
+  if (!existsSync7(skillDir)) throw new Error(`Skill not found: ${skillId}`);
+  const skillMdPath = join(skillDir, "SKILL.md");
+  if (!existsSync7(skillMdPath)) throw new Error(`SKILL.md not found in ${skillId}`);
+  return importSkillFromDir(skillDir, mindName);
+}
+function listFilesRecursive(dir, prefix = "") {
+  const results = [];
+  for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      results.push(...listFilesRecursive(join(dir, entry.name), rel));
+    } else {
+      results.push(rel);
+    }
+  }
+  return results;
+}
+
+// src/web/api/mind-skills.ts
+var app7 = new Hono7().get("/:name/skills", async (c) => {
+  const name = c.req.param("name");
+  const entry = findMind(name);
+  if (!entry) return c.json({ error: "Mind not found" }, 404);
+  const dir = mindDir(name);
+  const skills = await listMindSkills(dir);
+  return c.json(skills);
+}).post(
+  "/:name/skills/install",
+  requireAdmin,
+  zValidator2("json", z2.object({ skillId: z2.string() })),
+  async (c) => {
+    const name = c.req.param("name");
+    const entry = findMind(name);
+    if (!entry) return c.json({ error: "Mind not found" }, 404);
+    const { skillId } = c.req.valid("json");
+    const dir = mindDir(name);
+    try {
+      await installSkill(name, dir, skillId);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      return c.json({ error: msg }, 400);
+    }
+    return c.json({ ok: true });
+  }
+).post(
+  "/:name/skills/update",
+  requireAdmin,
+  zValidator2("json", z2.object({ skillId: z2.string() })),
+  async (c) => {
+    const name = c.req.param("name");
+    const entry = findMind(name);
+    if (!entry) return c.json({ error: "Mind not found" }, 404);
+    const { skillId } = c.req.valid("json");
+    const dir = mindDir(name);
+    try {
+      const result = await updateSkill(name, dir, skillId);
+      return c.json(result);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      return c.json({ error: msg }, 400);
+    }
+  }
+).post(
+  "/:name/skills/publish",
+  requireAdmin,
+  zValidator2("json", z2.object({ skillId: z2.string() })),
+  async (c) => {
+    const name = c.req.param("name");
+    const entry = findMind(name);
+    if (!entry) return c.json({ error: "Mind not found" }, 404);
+    const { skillId } = c.req.valid("json");
+    const dir = mindDir(name);
+    try {
+      const skill = await publishSkill(name, dir, skillId);
+      return c.json(skill);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      return c.json({ error: msg }, 400);
+    }
+  }
+).delete("/:name/skills/:skill", requireAdmin, async (c) => {
+  const name = c.req.param("name");
+  const skillName = c.req.param("skill");
+  const entry = findMind(name);
+  if (!entry) return c.json({ error: "Mind not found" }, 404);
+  const dir = mindDir(name);
+  try {
+    await uninstallSkill(name, dir, skillName);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return c.json({ error: msg }, 400);
+  }
+  return c.json({ ok: true });
+});
+var mind_skills_default = app7;
+
+// src/web/api/minds.ts
+import {
+  cpSync as cpSync2,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync5,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync7,
+  rmSync as rmSync2,
   statSync,
-  writeFileSync as writeFileSync5
+  writeFileSync as writeFileSync6
 } from "fs";
-import { join, resolve as resolve11 } from "path";
-import { zValidator as zValidator2 } from "@hono/zod-validator";
-import { and as and3, desc as desc2, eq as eq4, sql as sql3 } from "drizzle-orm";
-import { Hono as Hono7 } from "hono";
-import { z as z2 } from "zod";
+import { join as join2, resolve as resolve11 } from "path";
+import { zValidator as zValidator3 } from "@hono/zod-validator";
+import { and as and3, desc as desc2, eq as eq5, sql as sql3 } from "drizzle-orm";
+import { Hono as Hono8 } from "hono";
+import { z as z3 } from "zod";
 
 // src/lib/consolidate.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { readdirSync as readdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
 import { resolve as resolve9 } from "path";
 async function consolidateMemory(mindDir2) {
   const soulPath = resolve9(mindDir2, "home/SOUL.md");
   const memoryPath = resolve9(mindDir2, "home/MEMORY.md");
   const memoryDir = resolve9(mindDir2, "home/memory");
-  const soul = readFileSync4(soulPath, "utf-8");
+  const soul = readFileSync5(soulPath, "utf-8");
   const logs = [];
   try {
-    const files = readdirSync2(memoryDir).filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f)).sort();
+    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 = readFileSync4(resolve9(memoryDir, filename), "utf-8").trim();
+      const content2 = readFileSync5(resolve9(memoryDir, filename), "utf-8").trim();
       if (content2) {
         logs.push(`### ${date}
 
@@ -1966,7 +2259,7 @@ ${content2}`);
   const data = await res.json();
   const content = data.content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("").trim();
   if (content) {
-    writeFileSync3(memoryPath, `${content}
+    writeFileSync4(memoryPath, `${content}
 `);
     console.log("MEMORY.md created successfully.");
   } else {
@@ -1976,7 +2269,7 @@ ${content2}`);
 
 // src/lib/conversations.ts
 import { randomUUID } from "crypto";
-import { and as and2, desc, eq as eq3, inArray, isNull, sql as sql2 } from "drizzle-orm";
+import { and as and2, desc, eq as eq4, inArray, isNull, sql as sql2 } from "drizzle-orm";
 
 // src/lib/conversation-events.ts
 var subscribers = /* @__PURE__ */ new Map();
@@ -2008,13 +2301,17 @@ function publish(conversationId, event) {
 
 // src/lib/conversations.ts
 async function createConversation(mindName, channel, opts) {
-  const db2 = await getDb();
+  const db = await getDb();
   const id = randomUUID();
-  await db2.transaction(async (tx) => {
+  const type = opts?.type ?? "dm";
+  const name = opts?.name ?? null;
+  await db.transaction(async (tx) => {
     await tx.insert(conversations).values({
       id,
       mind_name: mindName,
       channel,
+      type,
+      name,
       user_id: opts?.userId ?? null,
       title: opts?.title ?? null
     });
@@ -2032,6 +2329,8 @@ async function createConversation(mindName, channel, opts) {
     id,
     mind_name: mindName,
     channel,
+    type,
+    name,
     user_id: opts?.userId ?? null,
     title: opts?.title ?? null,
     created_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -2039,41 +2338,58 @@ async function createConversation(mindName, channel, opts) {
   };
 }
 async function getConversation(id) {
-  const db2 = await getDb();
-  const row = await db2.select().from(conversations).where(eq3(conversations.id, id)).get();
+  const db = await getDb();
+  const row = await db.select().from(conversations).where(eq4(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(
+      eq4(conversationParticipants.conversation_id, conversationId),
+      eq4(conversationParticipants.user_id, userId)
+    )
+  );
+}
 async function getParticipants(conversationId) {
-  const db2 = await getDb();
-  const rows = await db2.select({
+  const db = await getDb();
+  const rows = await db.select({
     userId: conversationParticipants.user_id,
     username: users.username,
     userType: users.user_type,
     role: conversationParticipants.role
-  }).from(conversationParticipants).innerJoin(users, eq3(conversationParticipants.user_id, users.id)).where(eq3(conversationParticipants.conversation_id, conversationId)).all();
+  }).from(conversationParticipants).innerJoin(users, eq4(conversationParticipants.user_id, users.id)).where(eq4(conversationParticipants.conversation_id, conversationId)).all();
   return rows;
 }
 async function isParticipant(conversationId, userId) {
-  const db2 = await getDb();
-  const row = await db2.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(
+  const db = await getDb();
+  const row = await db.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(
     and2(
-      eq3(conversationParticipants.conversation_id, conversationId),
-      eq3(conversationParticipants.user_id, userId)
+      eq4(conversationParticipants.conversation_id, conversationId),
+      eq4(conversationParticipants.user_id, userId)
     )
   ).get();
   return row != null;
 }
 async function listConversationsForUser(userId) {
-  const db2 = await getDb();
-  const participantRows = await db2.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(eq3(conversationParticipants.user_id, userId)).all();
+  const db = await getDb();
+  const participantRows = await db.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(eq4(conversationParticipants.user_id, userId)).all();
   if (participantRows.length === 0) return [];
   const convIds = participantRows.map((r) => r.conversation_id);
-  return db2.select().from(conversations).where(inArray(conversations.id, convIds)).orderBy(desc(conversations.updated_at)).all();
+  return await db.select().from(conversations).where(inArray(conversations.id, convIds)).orderBy(desc(conversations.updated_at)).all();
 }
 async function isParticipantOrOwner(conversationId, userId) {
   if (await isParticipant(conversationId, userId)) return true;
-  const db2 = await getDb();
-  const row = await db2.select().from(conversations).where(and2(eq3(conversations.id, conversationId), eq3(conversations.user_id, userId))).get();
+  const db = await getDb();
+  const row = await db.select().from(conversations).where(and2(eq4(conversations.id, conversationId), eq4(conversations.user_id, userId))).get();
   return row != null;
 }
 async function deleteConversationForUser(id, userId) {
@@ -2082,15 +2398,15 @@ async function deleteConversationForUser(id, userId) {
   return true;
 }
 async function addMessage(conversationId, role, senderName, content) {
-  const db2 = await getDb();
+  const db = await getDb();
   const serialized = JSON.stringify(content);
-  const [result] = await db2.insert(messages).values({ conversation_id: conversationId, role, sender_name: senderName, content: serialized }).returning({ id: messages.id, created_at: messages.created_at });
-  await db2.update(conversations).set({ updated_at: sql2`datetime('now')` }).where(eq3(conversations.id, conversationId));
+  const [result] = await db.insert(messages).values({ conversation_id: conversationId, role, sender_name: senderName, content: serialized }).returning({ id: messages.id, created_at: messages.created_at });
+  await db.update(conversations).set({ updated_at: sql2`datetime('now')` }).where(eq4(conversations.id, conversationId));
   if (role === "user") {
     const firstText = content.find((b) => b.type === "text");
     const title = firstText ? firstText.text.slice(0, 80) : "";
     if (title) {
-      await db2.update(conversations).set({ title }).where(and2(eq3(conversations.id, conversationId), isNull(conversations.title)));
+      await db.update(conversations).set({ title }).where(and2(eq4(conversations.id, conversationId), isNull(conversations.title)));
     }
   }
   const msg = {
@@ -2112,8 +2428,8 @@ async function addMessage(conversationId, role, senderName, content) {
   return msg;
 }
 async function getMessages(conversationId) {
-  const db2 = await getDb();
-  const rows = await db2.select().from(messages).where(eq3(messages.conversation_id, conversationId)).orderBy(messages.created_at).all();
+  const db = await getDb();
+  const rows = await db.select().from(messages).where(eq4(messages.conversation_id, conversationId)).orderBy(messages.created_at).all();
   return rows.map((row) => {
     let content;
     try {
@@ -2128,15 +2444,15 @@ async function getMessages(conversationId) {
 async function listConversationsWithParticipants(userId) {
   const convs = await listConversationsForUser(userId);
   if (convs.length === 0) return [];
-  const db2 = await getDb();
+  const db = await getDb();
   const convIds = convs.map((c) => c.id);
-  const rows = await db2.select({
+  const rows = await db.select({
     conversationId: conversationParticipants.conversation_id,
     userId: users.id,
     username: users.username,
     userType: users.user_type,
     role: conversationParticipants.role
-  }).from(conversationParticipants).innerJoin(users, eq3(conversationParticipants.user_id, users.id)).where(inArray(conversationParticipants.conversation_id, convIds));
+  }).from(conversationParticipants).innerJoin(users, eq4(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);
@@ -2151,32 +2467,32 @@ async function listConversationsWithParticipants(userId) {
       role: r.role
     });
   }
-  const lastMsgIds = await db2.select({
+  const lastMsgIds = await db.select({
     conversationId: messages.conversation_id,
     maxId: sql2`MAX(${messages.id})`
   }).from(messages).where(inArray(messages.conversation_id, convIds)).groupBy(messages.conversation_id);
   const byLastMsg = /* @__PURE__ */ new Map();
   if (lastMsgIds.length > 0) {
-    const msgRows = await db2.select().from(messages).where(
+    const msgRows = await db.select().from(messages).where(
       inArray(
         messages.id,
         lastMsgIds.map((r) => r.maxId)
       )
     );
     for (const m of msgRows) {
-      let text2 = "";
+      let text = "";
       try {
         const parsed = JSON.parse(m.content);
         const blocks = Array.isArray(parsed) ? parsed : [];
         const textBlock = blocks.find((b) => b.type === "text");
-        if (textBlock && "text" in textBlock) text2 = textBlock.text;
+        if (textBlock && "text" in textBlock) text = textBlock.text;
       } catch {
-        text2 = m.content;
+        text = m.content;
       }
       byLastMsg.set(m.conversation_id, {
         role: m.role,
         senderName: m.sender_name,
-        text: text2,
+        text,
         createdAt: m.created_at
       });
     }
@@ -2188,10 +2504,10 @@ async function listConversationsWithParticipants(userId) {
   }));
 }
 async function findDMConversation(mindName, participantIds) {
-  const db2 = await getDb();
-  const mindConvs = await db2.select({ id: conversations.id }).from(conversations).where(eq3(conversations.mind_name, mindName)).all();
+  const db = await getDb();
+  const mindConvs = await db.select({ id: conversations.id }).from(conversations).where(and2(eq4(conversations.mind_name, mindName), eq4(conversations.type, "dm"))).all();
   for (const conv of mindConvs) {
-    const rows = await db2.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(eq3(conversationParticipants.conversation_id, conv.id)).all();
+    const rows = await db.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(eq4(conversationParticipants.conversation_id, conv.id)).all();
     if (rows.length !== 2) continue;
     const ids = new Set(rows.map((r) => r.user_id));
     if (ids.has(participantIds[0]) && ids.has(participantIds[1])) {
@@ -2201,17 +2517,42 @@ async function findDMConversation(mindName, participantIds) {
   return null;
 }
 async function deleteConversation(id) {
-  const db2 = await getDb();
-  await db2.delete(conversations).where(eq3(conversations.id, id));
+  const db = await getDb();
+  await db.delete(conversations).where(eq4(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(eq4(conversations.name, name), eq4(conversations.type, "channel"))).get();
+  return row ?? null;
+}
+async function listChannels() {
+  const db = await getDb();
+  return await db.select().from(conversations).where(eq4(conversations.type, "channel")).orderBy(conversations.name).all();
+}
+async function joinChannel(conversationId, userId) {
+  if (await isParticipant(conversationId, userId)) return;
+  await addParticipant(conversationId, userId);
+}
+async function leaveChannel(conversationId, userId) {
+  await removeParticipant(conversationId, userId);
 }
 
 // src/lib/convert-session.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
 import { homedir } from "os";
 import { resolve as resolve10 } from "path";
 function convertSession(opts) {
-  const lines = readFileSync5(opts.sessionPath, "utf-8").trim().split("\n");
+  const lines = readFileSync6(opts.sessionPath, "utf-8").trim().split("\n");
   const sessionId = randomUUID2();
   const idMap = /* @__PURE__ */ new Map();
   const messages2 = [];
@@ -2326,9 +2667,9 @@ function convertSession(opts) {
   }
   const projectId = opts.projectDir.replace(/\//g, "-");
   const sdkDir = resolve10(homedir(), ".claude", "projects", projectId);
-  mkdirSync3(sdkDir, { recursive: true });
+  mkdirSync4(sdkDir, { recursive: true });
   const sdkPath = resolve10(sdkDir, `${sessionId}.jsonl`);
-  writeFileSync4(sdkPath, `${sdkEvents.join("\n")}
+  writeFileSync5(sdkPath, `${sdkEvents.join("\n")}
 `);
   console.log(`Converted ${sdkEvents.length} messages \u2192 ${sdkPath}`);
   return sessionId;
@@ -2513,7 +2854,7 @@ function extractTextContent(content) {
 }
 function getDaemonPort() {
   try {
-    const data = JSON.parse(readFileSync6(resolve11(voluteHome(), "daemon.json"), "utf-8"));
+    const data = JSON.parse(readFileSync7(resolve11(voluteHome(), "daemon.json"), "utf-8"));
     return data.port;
   } catch (err) {
     if (err?.code !== "ENOENT") {
@@ -2576,7 +2917,7 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
   } catch {
   }
   if (existsSync8(tempWorktree)) {
-    rmSync(tempWorktree, { recursive: true, force: true });
+    rmSync2(tempWorktree, { recursive: true, force: true });
   }
   const templatesRoot = findTemplatesRoot();
   const { composedDir, manifest } = composeTemplate(templatesRoot, template);
@@ -2598,7 +2939,7 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
     copyTemplateToDir(composedDir, tempWorktree, mindName, manifest);
     const initDir = resolve11(tempWorktree, ".init");
     if (existsSync8(initDir)) {
-      rmSync(initDir, { recursive: true, force: true });
+      rmSync2(initDir, { recursive: true, force: true });
     }
     await gitExec(["add", "-A"], { cwd: tempWorktree });
     try {
@@ -2612,9 +2953,9 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
     } catch {
     }
     if (existsSync8(tempWorktree)) {
-      rmSync(tempWorktree, { recursive: true, force: true });
+      rmSync2(tempWorktree, { recursive: true, force: true });
     }
-    rmSync(composedDir, { recursive: true, force: true });
+    rmSync2(composedDir, { recursive: true, force: true });
   }
 }
 async function mergeTemplateBranch(worktreeDir) {
@@ -2642,14 +2983,15 @@ async function npmInstallAsMind(cwd, mindName) {
     await exec("npm", ["install"], { cwd });
   }
 }
-var createMindSchema = z2.object({
-  name: z2.string(),
-  template: z2.string().optional(),
-  stage: z2.enum(["seed", "sprouted"]).optional(),
-  description: z2.string().optional(),
-  model: z2.string().optional()
+var createMindSchema = z3.object({
+  name: z3.string(),
+  template: z3.string().optional(),
+  stage: z3.enum(["seed", "sprouted"]).optional(),
+  description: z3.string().optional(),
+  model: z3.string().optional(),
+  seedSoul: z3.string().optional()
 });
-var app7 = new Hono7().post("/", requireAdmin, zValidator2("json", createMindSchema), async (c) => {
+var app8 = new Hono8().post("/", requireAdmin, zValidator3("json", createMindSchema), async (c) => {
   const body = c.req.valid("json");
   const { name, template = "claude" } = body;
   const nameErr = validateMindName(name);
@@ -2665,11 +3007,17 @@ var app7 = new Hono7().post("/", requireAdmin, zValidator2("json", createMindSch
     applyInitFiles(dest);
     if (body.model) {
       const configPath = resolve11(dest, "home/.config/config.json");
-      const existing = existsSync8(configPath) ? JSON.parse(readFileSync6(configPath, "utf-8")) : {};
+      const existing = existsSync8(configPath) ? JSON.parse(readFileSync7(configPath, "utf-8")) : {};
       existing.model = body.model;
-      writeFileSync5(configPath, `${JSON.stringify(existing, null, 2)}
+      writeFileSync6(configPath, `${JSON.stringify(existing, null, 2)}
 `);
     }
+    const mindPrompts = await getMindPromptDefaults();
+    writeFileSync6(
+      resolve11(dest, "home/.config/prompts.json"),
+      `${JSON.stringify(mindPrompts, null, 2)}
+`
+    );
     const port = nextPort();
     addMind(name, port, body.stage);
     const homeDir = resolve11(dest, "home");
@@ -2684,7 +3032,7 @@ var app7 = new Hono7().post("/", requireAdmin, zValidator2("json", createMindSch
       await initTemplateBranch(dest, composedDir, manifest, name, env);
     } catch (err) {
       console.error(`[daemon] git setup failed for ${name}:`, err);
-      rmSync(resolve11(dest, ".git"), { recursive: true, force: true });
+      rmSync2(resolve11(dest, ".git"), { recursive: true, force: true });
       gitWarning = "Git setup failed \u2014 variants and upgrades won't be available until git is initialized.";
     }
     chownMindDir(dest, name);
@@ -2692,19 +3040,23 @@ var app7 = new Hono7().post("/", requireAdmin, zValidator2("json", createMindSch
       const descLine = body.description ? `
 The human who planted you described you as: "${body.description}"
 ` : "";
-      writeFileSync5(
-        resolve11(dest, "home/SOUL.md"),
-        `You are ${name}.
-
-You don't have a soul yet. You're a seed \u2014 a new mind in the process of discovering who you are.
-${descLine}
-Have a conversation with the human. Explore what kind of mind you want to be. When you're ready, write your SOUL.md and MEMORY.md, then run \`volute sprout\` to complete the transformation.
-`
-      );
+      const seedSoulRaw = body.seedSoul ?? await getPrompt("seed_soul", { name, description: descLine });
+      const seedSoul = body.seedSoul ? substitute(seedSoulRaw, { name, description: descLine }) : seedSoulRaw;
+      writeFileSync6(resolve11(dest, "home/SOUL.md"), seedSoul);
       const skillsDir = resolve11(dest, manifest.skillsDir);
       for (const skill of ["volute-mind", "memory", "sessions"]) {
         const skillPath = resolve11(skillsDir, skill);
-        if (existsSync8(skillPath)) rmSync(skillPath, { recursive: true, force: true });
+        if (existsSync8(skillPath)) rmSync2(skillPath, { recursive: true, force: true });
+      }
+    }
+    if (body.stage !== "seed") {
+      const customSoul = await getPromptIfCustom("default_soul");
+      if (customSoul) {
+        writeFileSync6(resolve11(dest, "home/SOUL.md"), customSoul.replace(/\{\{name\}\}/g, name));
+      }
+      const customMemory = await getPromptIfCustom("default_memory");
+      if (customMemory) {
+        writeFileSync6(resolve11(dest, "home/MEMORY.md"), customMemory);
       }
     }
     return c.json({
@@ -2716,14 +3068,14 @@ Have a conversation with the human. Explore what kind of mind you want to be. Wh
       ...gitWarning && { warning: gitWarning }
     });
   } catch (err) {
-    if (existsSync8(dest)) rmSync(dest, { recursive: true, force: true });
+    if (existsSync8(dest)) rmSync2(dest, { recursive: true, force: true });
     try {
       removeMind(name);
     } catch {
     }
     return c.json({ error: err instanceof Error ? err.message : "Failed to create mind" }, 500);
   } finally {
-    rmSync(composedDir, { recursive: true, force: true });
+    rmSync2(composedDir, { recursive: true, force: true });
   }
 }).post("/import", requireAdmin, async (c) => {
   let body;
@@ -2736,10 +3088,10 @@ Have a conversation with the human. Explore what kind of mind you want to be. Wh
   if (!wsDir || !existsSync8(resolve11(wsDir, "SOUL.md")) || !existsSync8(resolve11(wsDir, "IDENTITY.md"))) {
     return c.json({ error: "Invalid workspace: missing SOUL.md or IDENTITY.md" }, 400);
   }
-  const soul = readFileSync6(resolve11(wsDir, "SOUL.md"), "utf-8");
-  const identity = readFileSync6(resolve11(wsDir, "IDENTITY.md"), "utf-8");
+  const soul = readFileSync7(resolve11(wsDir, "SOUL.md"), "utf-8");
+  const identity = readFileSync7(resolve11(wsDir, "IDENTITY.md"), "utf-8");
   const userPath = resolve11(wsDir, "USER.md");
-  const user = existsSync8(userPath) ? readFileSync6(userPath, "utf-8") : "";
+  const user = existsSync8(userPath) ? readFileSync7(userPath, "utf-8") : "";
   const name = body.name ?? parseNameFromIdentity(identity) ?? "imported-mind";
   const template = body.template ?? "claude";
   const nameErr = validateMindName(name);
@@ -2765,26 +3117,26 @@ ${user.trimEnd()}
   try {
     copyTemplateToDir(composedDir, dest, name, manifest);
     applyInitFiles(dest);
-    writeFileSync5(resolve11(dest, "home/SOUL.md"), mergedSoul);
+    writeFileSync6(resolve11(dest, "home/SOUL.md"), mergedSoul);
     const wsMemoryPath = resolve11(wsDir, "MEMORY.md");
     const hasMemory = existsSync8(wsMemoryPath);
     if (hasMemory) {
-      const existingMemory = readFileSync6(wsMemoryPath, "utf-8");
-      writeFileSync5(
+      const existingMemory = readFileSync7(wsMemoryPath, "utf-8");
+      writeFileSync6(
         resolve11(dest, "home/MEMORY.md"),
         `${existingMemory.trimEnd()}${mergedMemoryExtra}`
       );
     } else if (user) {
-      writeFileSync5(resolve11(dest, "home/MEMORY.md"), `${user.trimEnd()}
+      writeFileSync6(resolve11(dest, "home/MEMORY.md"), `${user.trimEnd()}
 `);
     }
     const wsMemoryDir = resolve11(wsDir, "memory");
     let dailyLogCount = 0;
     if (existsSync8(wsMemoryDir)) {
       const destMemoryDir = resolve11(dest, "home/memory");
-      const files = readdirSync3(wsMemoryDir).filter((f) => f.endsWith(".md"));
+      const files = readdirSync4(wsMemoryDir).filter((f) => f.endsWith(".md"));
       for (const file of files) {
-        cpSync(resolve11(wsMemoryDir, file), resolve11(destMemoryDir, file));
+        cpSync2(resolve11(wsMemoryDir, file), resolve11(destMemoryDir, file));
       }
       dailyLogCount = files.length;
     }
@@ -2809,29 +3161,29 @@ ${user.trimEnd()}
       } else if (template === "claude") {
         const sessionId = convertSession({ sessionPath: sessionFile, projectDir: dest });
         const voluteDir = resolve11(dest, ".volute");
-        mkdirSync4(voluteDir, { recursive: true });
-        writeFileSync5(resolve11(voluteDir, "session.json"), JSON.stringify({ sessionId }));
+        mkdirSync5(voluteDir, { recursive: true });
+        writeFileSync6(resolve11(voluteDir, "session.json"), JSON.stringify({ sessionId }));
       }
     }
     importOpenClawConnectors(name, dest);
     chownMindDir(dest, name);
     return c.json({ ok: true, name, port, message: `Imported mind: ${name} (port ${port})` });
   } catch (err) {
-    if (existsSync8(dest)) rmSync(dest, { recursive: true, force: true });
+    if (existsSync8(dest)) rmSync2(dest, { recursive: true, force: true });
     try {
       removeMind(name);
     } catch {
     }
     return c.json({ error: err instanceof Error ? err.message : "Failed to import mind" }, 500);
   } finally {
-    rmSync(composedDir, { recursive: true, force: true });
+    rmSync2(composedDir, { recursive: true, force: true });
   }
 }).get("/", async (c) => {
   const entries = readRegistry();
   let lastActiveMap = /* @__PURE__ */ new Map();
   try {
-    const db2 = await getDb();
-    const lastActiveRows = await db2.select({
+    const db = await getDb();
+    const lastActiveRows = await db.select({
       mind: mindHistory.mind,
       lastActiveAt: sql3`MAX(${mindHistory.created_at})`
     }).from(mindHistory).groupBy(mindHistory.mind);
@@ -2860,7 +3212,7 @@ ${user.trimEnd()}
     if (!existsSync8(pagesDir)) continue;
     let items;
     try {
-      items = readdirSync3(pagesDir);
+      items = readdirSync4(pagesDir);
     } catch (err) {
       logger_default.warn("Failed to read pages dir", { mind: entry.name, error: err.message });
       continue;
@@ -2882,7 +3234,7 @@ ${user.trimEnd()}
             const indexStat = statSync(indexPath);
             pages.push({
               mind: entry.name,
-              file: join(item, "index.html"),
+              file: join2(item, "index.html"),
               modified: indexStat.mtime.toISOString(),
               url: `/pages/${entry.name}/${item}/`
             });
@@ -3036,8 +3388,8 @@ ${user.trimEnd()}
     }
     if (context?.type === "sprouted" && !variantName) {
       try {
-        const db2 = await getDb();
-        const activeConvs = await db2.select({ id: conversations.id }).from(conversations).where(eq4(conversations.mind_name, baseName)).all();
+        const db = await getDb();
+        const activeConvs = await db.select({ id: conversations.id }).from(conversations).where(eq5(conversations.mind_name, baseName)).all();
         for (const conv of activeConvs) {
           await addMessage(conv.id, "assistant", "system", [
             { type: "text", text: "[seed has sprouted]" }
@@ -3102,10 +3454,10 @@ ${user.trimEnd()}
   await deleteMindUser2(name);
   const state = stateDir(name);
   if (existsSync8(state)) {
-    rmSync(state, { recursive: true, force: true });
+    rmSync2(state, { recursive: true, force: true });
   }
   if (force && existsSync8(dir)) {
-    rmSync(dir, { recursive: true, force: true });
+    rmSync2(dir, { recursive: true, force: true });
     deleteMindUser(name);
   }
   return c.json({ ok: true });
@@ -3199,7 +3551,7 @@ ${user.trimEnd()}
   await updateTemplateBranch(dir, template, mindName);
   const parentDir = resolve11(dir, ".variants");
   if (!existsSync8(parentDir)) {
-    mkdirSync4(parentDir, { recursive: true });
+    mkdirSync5(parentDir, { recursive: true });
   }
   await gitExec(["worktree", "add", "-b", UPGRADE_VARIANT, worktreeDir], { cwd: dir });
   const hasConflicts = await mergeTemplateBranch(worktreeDir);
@@ -3277,12 +3629,12 @@ ${user.trimEnd()}
     console.error(`[daemon] failed to parse message body for ${baseName}:`, err);
   }
   const channel = parsed?.channel ?? "unknown";
-  const db2 = await getDb();
+  const db = await getDb();
   if (parsed) {
     try {
       const sender2 = parsed.sender ?? null;
       const content = extractTextContent(parsed.content);
-      await db2.insert(mindHistory).values({
+      await db.insert(mindHistory).values({
         mind: baseName,
         type: "inbound",
         channel,
@@ -3329,7 +3681,7 @@ ${user.trimEnd()}
   const seedEntry = findMind(baseName);
   if (seedEntry?.stage === "seed" && parsed) {
     try {
-      const countResult = await db2.select({ count: sql3`count(*)` }).from(mindHistory).where(eq4(mindHistory.mind, baseName));
+      const countResult = await db.select({ count: sql3`count(*)` }).from(mindHistory).where(eq5(mindHistory.mind, baseName));
       const msgCount = countResult[0]?.count ?? 0;
       if (msgCount >= 10 && msgCount % 10 === 0) {
         const nudge = "\n[You've been exploring for a while. Whenever you feel ready, write your SOUL.md and MEMORY.md, then run volute sprout.]";
@@ -3353,8 +3705,8 @@ ${user.trimEnd()}
     body: forwardBody
   }).then(async (res) => {
     if (!res.ok) {
-      const text2 = await res.text().catch(() => "");
-      console.error(`[daemon] mind ${name} responded with ${res.status}: ${text2}`);
+      const text = await res.text().catch(() => "");
+      console.error(`[daemon] mind ${name} responded with ${res.status}: ${text}`);
     }
   }).catch((err) => {
     console.error(`[daemon] mind ${name} unreachable on port ${port}:`, err);
@@ -3379,9 +3731,9 @@ ${user.trimEnd()}
   if (!body.type) {
     return c.json({ error: "type required" }, 400);
   }
-  const db2 = await getDb();
+  const db = await getDb();
   try {
-    await db2.insert(mindHistory).values({
+    await db.insert(mindHistory).values({
       mind: baseName,
       type: body.type,
       session: body.session ?? null,
@@ -3465,9 +3817,9 @@ ${user.trimEnd()}
   if (!body.channel || !body.content) {
     return c.json({ error: "channel and content required" }, 400);
   }
-  const db2 = await getDb();
+  const db = await getDb();
   try {
-    await db2.insert(mindHistory).values({
+    await db.insert(mindHistory).values({
       mind: baseName,
       type: "outbound",
       channel: body.channel,
@@ -3481,19 +3833,19 @@ ${user.trimEnd()}
   return c.json({ ok: true });
 }).get("/:name/history/sessions", async (c) => {
   const name = c.req.param("name");
-  const db2 = await getDb();
-  const rows = await db2.select({
+  const db = await getDb();
+  const rows = await db.select({
     session: mindHistory.session,
     started_at: sql3`MIN(${mindHistory.created_at})`,
     event_count: sql3`COUNT(*)`,
     message_count: sql3`SUM(CASE WHEN ${mindHistory.type} IN ('inbound','outbound') THEN 1 ELSE 0 END)`,
     tool_count: sql3`SUM(CASE WHEN ${mindHistory.type}='tool_use' THEN 1 ELSE 0 END)`
-  }).from(mindHistory).where(and3(eq4(mindHistory.mind, name), sql3`${mindHistory.session} IS NOT NULL`)).groupBy(mindHistory.session).orderBy(sql3`MIN(${mindHistory.created_at}) DESC`);
+  }).from(mindHistory).where(and3(eq5(mindHistory.mind, name), sql3`${mindHistory.session} IS NOT NULL`)).groupBy(mindHistory.session).orderBy(sql3`MIN(${mindHistory.created_at}) DESC`);
   return c.json(rows);
 }).get("/:name/history/channels", async (c) => {
   const name = c.req.param("name");
-  const db2 = await getDb();
-  const rows = await db2.selectDistinct({ channel: mindHistory.channel }).from(mindHistory).where(eq4(mindHistory.mind, name));
+  const db = await getDb();
+  const rows = await db.selectDistinct({ channel: mindHistory.channel }).from(mindHistory).where(eq5(mindHistory.mind, name));
   return c.json(rows.map((r) => r.channel));
 }).get("/:name/history", async (c) => {
   const name = c.req.param("name");
@@ -3502,26 +3854,26 @@ ${user.trimEnd()}
   const full = c.req.query("full") === "true";
   const limit = Math.min(Math.max(parseInt(c.req.query("limit") ?? "50", 10) || 50, 1), 200);
   const offset = Math.max(parseInt(c.req.query("offset") ?? "0", 10) || 0, 0);
-  const db2 = await getDb();
-  const conditions = [eq4(mindHistory.mind, name)];
+  const db = await getDb();
+  const conditions = [eq5(mindHistory.mind, name)];
   if (channel) {
-    conditions.push(eq4(mindHistory.channel, channel));
+    conditions.push(eq5(mindHistory.channel, channel));
   }
   if (session) {
-    conditions.push(eq4(mindHistory.session, session));
+    conditions.push(eq5(mindHistory.session, session));
   }
   if (!full) {
     conditions.push(sql3`${mindHistory.type} IN ('inbound', 'outbound')`);
   }
-  const rows = await db2.select().from(mindHistory).where(and3(...conditions)).orderBy(desc2(mindHistory.created_at)).limit(limit).offset(offset);
+  const rows = await db.select().from(mindHistory).where(and3(...conditions)).orderBy(desc2(mindHistory.created_at)).limit(limit).offset(offset);
   return c.json(rows);
 });
-var minds_default = app7;
+var minds_default = app8;
 
 // src/web/api/pages.ts
 import { readFile as readFile2, stat } from "fs/promises";
 import { extname, resolve as resolve12 } from "path";
-import { Hono as Hono8 } from "hono";
+import { Hono as Hono9 } from "hono";
 var MIME_TYPES = {
   ".html": "text/html",
   ".js": "application/javascript",
@@ -3538,7 +3890,7 @@ var MIME_TYPES = {
   ".txt": "text/plain",
   ".xml": "application/xml"
 };
-var app8 = new Hono8().get("/:name/*", async (c) => {
+var app9 = new Hono9().get("/:name/*", async (c) => {
   const name = c.req.param("name");
   if (!findMind(name)) return c.text("Not found", 404);
   const pagesRoot = resolve12(mindDir(name), "home", "pages");
@@ -3563,10 +3915,61 @@ var app8 = new Hono8().get("/:name/*", async (c) => {
   }
   return c.text("Not found", 404);
 });
-var pages_default = app8;
+var pages_default = app9;
+
+// src/web/api/prompts.ts
+import { zValidator as zValidator4 } from "@hono/zod-validator";
+import { eq as eq6, sql as sql4 } from "drizzle-orm";
+import { Hono as Hono10 } from "hono";
+import { z as z4 } from "zod";
+var app10 = new Hono10().get("/", async (c) => {
+  let rows;
+  try {
+    const db = await getDb();
+    rows = await db.select().from(systemPrompts).all();
+  } catch (err) {
+    console.error("[prompts] failed to query system_prompts:", err);
+    return c.json({ error: "Failed to load prompts from database" }, 500);
+  }
+  const customMap = new Map(rows.map((r) => [r.key, r.content]));
+  const prompts = PROMPT_KEYS.map((key) => {
+    const meta = PROMPT_DEFAULTS[key];
+    const custom = customMap.get(key);
+    return {
+      key,
+      content: custom ?? meta.content,
+      description: meta.description,
+      variables: meta.variables,
+      isCustom: custom !== void 0,
+      category: meta.category
+    };
+  });
+  return c.json(prompts);
+}).put("/:key", requireAdmin, zValidator4("json", z4.object({ content: z4.string() })), async (c) => {
+  const key = c.req.param("key");
+  if (!PROMPT_KEYS.includes(key)) {
+    return c.json({ error: "Unknown prompt key" }, 404);
+  }
+  const { content } = c.req.valid("json");
+  const db = await getDb();
+  await db.insert(systemPrompts).values({ key, content, updated_at: sql4`(datetime('now'))` }).onConflictDoUpdate({
+    target: systemPrompts.key,
+    set: { content, updated_at: sql4`(datetime('now'))` }
+  });
+  return c.json({ ok: true });
+}).delete("/:key", requireAdmin, async (c) => {
+  const key = c.req.param("key");
+  if (!PROMPT_KEYS.includes(key)) {
+    return c.json({ error: "Unknown prompt key" }, 404);
+  }
+  const db = await getDb();
+  await db.delete(systemPrompts).where(eq6(systemPrompts.key, key));
+  return c.json({ ok: true });
+});
+var prompts_default = app10;
 
 // src/web/api/schedules.ts
-import { Hono as Hono9 } from "hono";
+import { Hono as Hono11 } from "hono";
 function readSchedules(name) {
   return readVoluteConfig(mindDir(name))?.schedules ?? [];
 }
@@ -3577,7 +3980,7 @@ function writeSchedules(name, schedules) {
   writeVoluteConfig(dir, config);
   getScheduler().loadSchedules(name);
 }
-var app9 = new Hono9().get("/:name/schedules", (c) => {
+var app11 = new Hono11().get("/:name/schedules", (c) => {
   const name = c.req.param("name");
   if (!findMind(name)) return c.json({ error: "Mind not found" }, 404);
   return c.json(readSchedules(name));
@@ -3648,12 +4051,85 @@ var app9 = new Hono9().get("/:name/schedules", (c) => {
     return c.json({ error: "Failed to reach mind" }, 502);
   }
 });
-var schedules_default = app9;
+var schedules_default = app11;
+
+// src/web/api/skills.ts
+import { existsSync as existsSync9, mkdtempSync, readdirSync as readdirSync5, rmSync as rmSync3 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join3, resolve as resolve13 } from "path";
+import AdmZip from "adm-zip";
+import { Hono as Hono12 } from "hono";
+var app12 = new Hono12().get("/", async (c) => {
+  const skills = await listSharedSkills();
+  return c.json(skills);
+}).get("/:id", async (c) => {
+  const id = c.req.param("id");
+  const skill = await getSharedSkill(id);
+  if (!skill) return c.json({ error: "Skill not found" }, 404);
+  const dir = join3(sharedSkillsDir(), id);
+  const files = listFilesRecursive(dir);
+  return c.json({ ...skill, files });
+}).post("/upload", requireAdmin, async (c) => {
+  const body = await c.req.parseBody();
+  const file = body.file;
+  if (!file || !(file instanceof File)) {
+    return c.json({ error: "No file uploaded" }, 400);
+  }
+  if (!file.name.endsWith(".zip")) {
+    return c.json({ error: "Only .zip files are accepted" }, 400);
+  }
+  const buffer = Buffer.from(await file.arrayBuffer());
+  const tmpDir = mkdtempSync(join3(tmpdir2(), "volute-skill-upload-"));
+  try {
+    const zip = new AdmZip(buffer);
+    for (const entry of zip.getEntries()) {
+      const target = resolve13(tmpDir, entry.entryName);
+      if (!target.startsWith(tmpDir)) {
+        return c.json({ error: "Invalid zip: paths must not escape archive" }, 400);
+      }
+    }
+    zip.extractAllTo(tmpDir, true);
+    let skillDir = null;
+    if (existsSync9(join3(tmpDir, "SKILL.md"))) {
+      skillDir = tmpDir;
+    } else {
+      const entries = readdirSync5(tmpDir, { withFileTypes: true }).filter((e) => e.isDirectory());
+      for (const entry of entries) {
+        if (existsSync9(join3(tmpDir, entry.name, "SKILL.md"))) {
+          skillDir = join3(tmpDir, entry.name);
+          break;
+        }
+      }
+    }
+    if (!skillDir) {
+      return c.json({ error: "No SKILL.md found in zip (checked root and one level deep)" }, 400);
+    }
+    const skill = await importSkillFromDir(skillDir, "upload");
+    return c.json(skill);
+  } catch (e) {
+    if (e instanceof Error && e.message.includes("Invalid skill ID")) {
+      return c.json({ error: e.message }, 400);
+    }
+    throw e;
+  } finally {
+    rmSync3(tmpDir, { recursive: true, force: true });
+  }
+}).delete("/:id", requireAdmin, async (c) => {
+  const id = c.req.param("id");
+  try {
+    await removeSharedSkill(id);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return c.json({ error: msg }, 404);
+  }
+  return c.json({ ok: true });
+});
+var skills_default = app12;
 
 // src/web/api/system.ts
-import { Hono as Hono10 } from "hono";
+import { Hono as Hono13 } from "hono";
 import { streamSSE as streamSSE2 } from "hono/streaming";
-var app10 = new Hono10().post("/restart", requireAdmin, (c) => {
+var app13 = new Hono13().post("/restart", requireAdmin, (c) => {
   setTimeout(() => process.exit(1), 200);
   return c.json({ ok: true });
 }).post("/stop", requireAdmin, (c) => {
@@ -3670,10 +4146,10 @@ var app10 = new Hono10().post("/restart", requireAdmin, (c) => {
       stream.writeSSE({ data: JSON.stringify(entry) }).catch(() => {
       });
     });
-    await new Promise((resolve18) => {
+    await new Promise((resolve19) => {
       stream.onAbort(() => {
         unsubscribe();
-        resolve18();
+        resolve19();
       });
     });
   });
@@ -3681,18 +4157,18 @@ var app10 = new Hono10().post("/restart", requireAdmin, (c) => {
   const config = readSystemsConfig();
   return c.json({ system: config?.system ?? null });
 });
-var system_default = app10;
+var system_default = app13;
 
 // src/web/api/typing.ts
-import { zValidator as zValidator3 } from "@hono/zod-validator";
-import { Hono as Hono11 } from "hono";
-import { z as z3 } from "zod";
-var typingSchema = z3.object({
-  channel: z3.string().min(1),
-  sender: z3.string().min(1),
-  active: z3.boolean()
+import { zValidator as zValidator5 } from "@hono/zod-validator";
+import { Hono as Hono14 } from "hono";
+import { z as z5 } from "zod";
+var typingSchema = z5.object({
+  channel: z5.string().min(1),
+  sender: z5.string().min(1),
+  active: z5.boolean()
 });
-var app11 = new Hono11().post("/:name/typing", zValidator3("json", typingSchema), (c) => {
+var app14 = new Hono14().post("/:name/typing", zValidator5("json", typingSchema), (c) => {
   const { channel, sender, active } = c.req.valid("json");
   const map = getTypingMap();
   if (active) {
@@ -3709,13 +4185,13 @@ var app11 = new Hono11().post("/:name/typing", zValidator3("json", typingSchema)
   const map = getTypingMap();
   return c.json({ typing: map.get(channel) });
 });
-var typing_default = app11;
+var typing_default = app14;
 
 // src/web/api/update.ts
 import { spawn as spawn3 } from "child_process";
-import { Hono as Hono12 } from "hono";
+import { Hono as Hono15 } from "hono";
 var bin;
-var app12 = new Hono12().get("/update", async (c) => {
+var app15 = new Hono15().get("/update", async (c) => {
   const result = await checkForUpdate();
   return c.json(result);
 }).post("/update", requireAdmin, async (c) => {
@@ -3730,19 +4206,19 @@ var app12 = new Hono12().get("/update", async (c) => {
   child.unref();
   return c.json({ ok: true, message: "Updating..." });
 });
-var update_default = app12;
+var update_default = app15;
 
 // src/web/api/variants.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "fs";
-import { resolve as resolve14 } from "path";
-import { Hono as Hono13 } from "hono";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "fs";
+import { resolve as resolve15 } from "path";
+import { Hono as Hono16 } from "hono";
 
 // src/lib/spawn-server.ts
 import { spawn as spawn4 } from "child_process";
-import { closeSync, mkdirSync as mkdirSync5, openSync, readFileSync as readFileSync7 } from "fs";
-import { resolve as resolve13 } from "path";
+import { closeSync, mkdirSync as mkdirSync6, openSync, readFileSync as readFileSync8 } from "fs";
+import { resolve as resolve14 } from "path";
 function tsxBin(cwd) {
-  return resolve13(cwd, "node_modules", ".bin", "tsx");
+  return resolve14(cwd, "node_modules", ".bin", "tsx");
 }
 function spawnServer(cwd, port, options) {
   if (options?.detached) {
@@ -3755,31 +4231,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 ?? resolve13(cwd, ".volute", "logs");
-  mkdirSync5(logsDir, { recursive: true });
-  const logPath = resolve13(logsDir, "mind.log");
+  const logsDir = logDir ?? resolve14(cwd, ".volute", "logs");
+  mkdirSync6(logsDir, { recursive: true });
+  const logPath = resolve14(logsDir, "mind.log");
   const logFd = openSync(logPath, "a");
   const child = spawn4(tsxBin(cwd), ["src/server.ts", "--port", String(port)], {
     cwd,
@@ -3799,7 +4275,7 @@ function spawnDetached(cwd, port, logDir) {
     }
     const interval = setInterval(() => {
       try {
-        const content = readFileSync7(logPath, "utf-8");
+        const content = readFileSync8(logPath, "utf-8");
         const match = content.match(/listening on :(\d+)/);
         if (match) {
           finish({ child, actualPort: parseInt(match[1], 10) });
@@ -3851,7 +4327,7 @@ async function verify(port) {
 }
 
 // src/web/api/variants.ts
-var app13 = new Hono13().get("/:name/variants", async (c) => {
+var app16 = new Hono16().get("/:name/variants", async (c) => {
   const name = c.req.param("name");
   const entry = findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
@@ -3881,11 +4357,11 @@ var app13 = new Hono13().get("/:name/variants", async (c) => {
   const err = validateBranchName(variantName);
   if (err) return c.json({ error: err }, 400);
   const projectRoot = mindDir(mindName);
-  const variantDir = resolve14(projectRoot, ".variants", variantName);
-  if (existsSync9(variantDir)) {
+  const variantDir = resolve15(projectRoot, ".variants", variantName);
+  if (existsSync10(variantDir)) {
     return c.json({ error: `Variant directory already exists: ${variantDir}` }, 409);
   }
-  mkdirSync6(resolve14(projectRoot, ".variants"), { recursive: true });
+  mkdirSync7(resolve15(projectRoot, ".variants"), { recursive: true });
   try {
     await gitExec(["worktree", "add", "-b", variantName, variantDir], { cwd: projectRoot });
   } catch (e) {
@@ -3898,7 +4374,7 @@ var app13 = new Hono13().get("/:name/variants", async (c) => {
       const [cmd, args] = wrapForIsolation("npm", ["install"], mindName);
       await exec(cmd, args, {
         cwd: variantDir,
-        env: { ...process.env, HOME: resolve14(variantDir, "home") }
+        env: { ...process.env, HOME: resolve15(variantDir, "home") }
       });
     } else {
       await exec("npm", ["install"], { cwd: variantDir });
@@ -3908,7 +4384,7 @@ var app13 = new Hono13().get("/:name/variants", async (c) => {
     return c.json({ error: `npm install failed: ${msg}` }, 500);
   }
   if (body.soul) {
-    writeFileSync6(resolve14(variantDir, "home/SOUL.md"), body.soul);
+    writeFileSync7(resolve15(variantDir, "home/SOUL.md"), body.soul);
   }
   const variantPort = body.port ?? nextPort();
   const variant = {
@@ -3946,7 +4422,7 @@ var app13 = new Hono13().get("/:name/variants", async (c) => {
   } catch {
   }
   const projectRoot = mindDir(mindName);
-  if (existsSync9(variant.path)) {
+  if (existsSync10(variant.path)) {
     const status = (await gitExec(["status", "--porcelain"], { cwd: variant.path })).trim();
     if (status) {
       try {
@@ -4003,7 +4479,7 @@ var app13 = new Hono13().get("/:name/variants", async (c) => {
   } catch (e) {
     return c.json({ error: "Merge failed. Resolve conflicts manually." }, 500);
   }
-  if (existsSync9(variant.path)) {
+  if (existsSync10(variant.path)) {
     try {
       await gitExec(["worktree", "remove", "--force", variant.path], { cwd: projectRoot });
     } catch {
@@ -4020,7 +4496,7 @@ var app13 = new Hono13().get("/:name/variants", async (c) => {
       const [cmd, args] = wrapForIsolation("npm", ["install"], mindName);
       await exec(cmd, args, {
         cwd: projectRoot,
-        env: { ...process.env, HOME: resolve14(projectRoot, "home") }
+        env: { ...process.env, HOME: resolve15(projectRoot, "home") }
       });
     } else {
       await exec("npm", ["install"], { cwd: projectRoot });
@@ -4063,7 +4539,7 @@ var app13 = new Hono13().get("/:name/variants", async (c) => {
     } catch {
     }
   }
-  if (existsSync9(variant.path)) {
+  if (existsSync10(variant.path)) {
     try {
       await gitExec(["worktree", "remove", "--force", variant.path], { cwd: projectRoot });
     } catch {
@@ -4077,29 +4553,83 @@ var app13 = new Hono13().get("/:name/variants", async (c) => {
   chownMindDir(projectRoot, mindName);
   return c.json({ ok: true });
 });
-var variants_default = app13;
+var variants_default = app16;
+
+// src/web/api/volute/channels.ts
+import { zValidator as zValidator6 } from "@hono/zod-validator";
+import { Hono as Hono17 } from "hono";
+import { z as z6 } from "zod";
+var createSchema = z6.object({
+  name: z6.string().min(1).max(50).regex(/^[a-z0-9][a-z0-9-]*$/, "Channel names must be lowercase alphanumeric with hyphens")
+});
+var app17 = new Hono17().get("/", async (c) => {
+  const user = c.get("user");
+  const channels = await listChannels();
+  const results = await Promise.all(
+    channels.map(async (ch) => {
+      const participants = await getParticipants(ch.id);
+      const isMember = participants.some((p) => p.userId === user.id);
+      return { ...ch, participantCount: participants.length, isMember };
+    })
+  );
+  return c.json(results);
+}).post("/", zValidator6("json", createSchema), async (c) => {
+  const user = c.get("user");
+  const body = c.req.valid("json");
+  try {
+    const ch = await createChannel(body.name, user.id);
+    return c.json(ch, 201);
+  } catch (err) {
+    const cause = err instanceof Error ? err.cause : null;
+    if (cause && /UNIQUE/i.test(cause.extendedCode ?? cause.message ?? "")) {
+      return c.json({ error: "Channel already exists" }, 409);
+    }
+    throw err;
+  }
+}).post("/:name/join", async (c) => {
+  const name = c.req.param("name");
+  const user = c.get("user");
+  const ch = await getChannelByName(name);
+  if (!ch) return c.json({ error: "Channel not found" }, 404);
+  await joinChannel(ch.id, user.id);
+  return c.json({ ok: true, conversationId: ch.id });
+}).post("/:name/leave", async (c) => {
+  const name = c.req.param("name");
+  const user = c.get("user");
+  const ch = await getChannelByName(name);
+  if (!ch) return c.json({ error: "Channel not found" }, 404);
+  await leaveChannel(ch.id, user.id);
+  return c.json({ ok: true });
+}).get("/:name/members", async (c) => {
+  const name = c.req.param("name");
+  const ch = await getChannelByName(name);
+  if (!ch) return c.json({ error: "Channel not found" }, 404);
+  const participants = await getParticipants(ch.id);
+  return c.json(participants);
+});
+var channels_default2 = app17;
 
 // src/web/api/volute/chat.ts
-import { readFileSync as readFileSync8 } from "fs";
-import { resolve as resolve15 } from "path";
-import { zValidator as zValidator4 } from "@hono/zod-validator";
-import { Hono as Hono14 } from "hono";
+import { readFileSync as readFileSync9 } from "fs";
+import { resolve as resolve16 } from "path";
+import { zValidator as zValidator7 } from "@hono/zod-validator";
+import { Hono as Hono18 } from "hono";
 import { streamSSE as streamSSE3 } from "hono/streaming";
-import { z as z4 } from "zod";
-var chatSchema = z4.object({
-  message: z4.string().optional(),
-  conversationId: z4.string().optional(),
-  sender: z4.string().optional(),
-  images: z4.array(
-    z4.object({
-      media_type: z4.string(),
-      data: z4.string()
+import { z as z7 } from "zod";
+var chatSchema = z7.object({
+  message: z7.string().optional(),
+  conversationId: z7.string().optional(),
+  sender: z7.string().optional(),
+  images: z7.array(
+    z7.object({
+      media_type: z7.string(),
+      data: z7.string()
     })
   ).optional()
 });
 function getDaemonUrl() {
   try {
-    const data = JSON.parse(readFileSync8(resolve15(voluteHome(), "daemon.json"), "utf-8"));
+    const data = JSON.parse(readFileSync9(resolve16(voluteHome(), "daemon.json"), "utf-8"));
     return `http://${daemonLoopback()}:${data.port}`;
   } catch (err) {
     throw new Error(`Failed to read daemon config: ${err instanceof Error ? err.message : err}`);
@@ -4115,7 +4645,7 @@ function daemonFetchInternal(path, body) {
   if (token) headers.Authorization = `Bearer ${token}`;
   return fetch(`${daemonUrl}${path}`, { method: "POST", headers, body });
 }
-var app14 = new Hono14().post("/:name/chat", zValidator4("json", chatSchema), async (c) => {
+var app18 = new Hono18().post("/:name/chat", zValidator7("json", chatSchema), async (c) => {
   const name = c.req.param("name");
   const [baseName] = name.split("@", 2);
   const entry = findMind(baseName);
@@ -4176,7 +4706,7 @@ var app14 = new Hono14().post("/:name/chat", zValidator4("json", chatSchema), as
   const participants = await getParticipants(conversationId);
   const mindParticipants = participants.filter((p) => p.userType === "mind");
   const participantNames = participants.map((p) => p.username);
-  const { getMindManager: getMindManager2 } = await import("./mind-manager-ETNCPQJN.js");
+  const { getMindManager: getMindManager2 } = await import("./mind-manager-Z7O7PN2O.js");
   const manager = getMindManager2();
   const runningMinds = mindParticipants.map((ap) => {
     const mindKey = ap.username === baseName ? name : ap.username;
@@ -4221,8 +4751,8 @@ var app14 = new Hono14().post("/:name/chat", zValidator4("json", chatSchema), as
     });
     daemonFetchInternal(`/api/minds/${encodeURIComponent(targetName)}/message`, payload).then(async (res) => {
       if (!res.ok) {
-        const text2 = await res.text().catch(() => "");
-        console.error(`[chat] mind ${mindName} responded ${res.status}: ${text2}`);
+        const text = await res.text().catch(() => "");
+        console.error(`[chat] mind ${mindName} responded ${res.status}: ${text}`);
       }
     }).catch((err) => {
       console.error(`[chat] mind ${mindName} unreachable via daemon:`, err);
@@ -4246,27 +4776,116 @@ var app14 = new Hono14().post("/:name/chat", zValidator4("json", chatSchema), as
         if (!stream.aborted) console.error("[chat] SSE ping error:", err);
       });
     }, 15e3);
-    await new Promise((resolve18) => {
+    await new Promise((resolve19) => {
       stream.onAbort(() => {
         unsubscribe();
         clearInterval(keepAlive);
-        resolve18();
+        resolve19();
       });
     });
   });
 });
-var chat_default = app14;
+var unifiedChatSchema = z7.object({
+  message: z7.string().optional(),
+  conversationId: z7.string(),
+  images: z7.array(z7.object({ media_type: z7.string(), data: z7.string() })).optional()
+});
+var unifiedChatApp = new Hono18().post(
+  "/chat",
+  zValidator7("json", unifiedChatSchema),
+  async (c) => {
+    const user = c.get("user");
+    const body = c.req.valid("json");
+    if (!body.message && (!body.images || body.images.length === 0)) {
+      return c.json({ error: "message or images required" }, 400);
+    }
+    const conv = await getConversation(body.conversationId);
+    if (!conv) return c.json({ error: "Conversation not found" }, 404);
+    if (user.id !== 0 && !await isParticipantOrOwner(body.conversationId, user.id)) {
+      return c.json({ error: "Conversation not found" }, 404);
+    }
+    const senderName = user.username;
+    const contentBlocks = [];
+    if (body.message) contentBlocks.push({ type: "text", text: body.message });
+    if (body.images) {
+      for (const img of body.images) {
+        contentBlocks.push({ type: "image", media_type: img.media_type, data: img.data });
+      }
+    }
+    await addMessage(body.conversationId, "user", senderName, contentBlocks);
+    const participants = await getParticipants(body.conversationId);
+    const mindParticipants = participants.filter((p) => p.userType === "mind");
+    const participantNames = participants.map((p) => p.username);
+    const { getMindManager: getMindManager2 } = await import("./mind-manager-Z7O7PN2O.js");
+    const manager = getMindManager2();
+    const runningMinds = mindParticipants.map((ap) => manager.isRunning(ap.username) ? ap.username : null).filter((n) => n !== null && n !== senderName);
+    const isDM = conv.type === "dm" && participants.length === 2;
+    const channelEntry = {
+      platformId: body.conversationId,
+      platform: "volute",
+      name: conv.title ?? void 0,
+      type: conv.type === "channel" ? "group" : isDM ? "dm" : "group"
+    };
+    for (const ap of mindParticipants) {
+      const slug = buildVoluteSlug({
+        participants,
+        mindUsername: ap.username,
+        convTitle: conv.title,
+        conversationId: conv.id,
+        convType: conv.type,
+        convName: conv.name
+      });
+      try {
+        writeChannelEntry(ap.username, slug, channelEntry);
+      } catch (err) {
+        console.warn(`[chat] failed to write channel entry for ${ap.username}:`, err);
+      }
+    }
+    for (const mindName of runningMinds) {
+      const channel = buildVoluteSlug({
+        participants,
+        mindUsername: mindName,
+        convTitle: conv.title,
+        conversationId: body.conversationId,
+        convType: conv.type,
+        convName: conv.name
+      });
+      const typingMap = getTypingMap();
+      const currentlyTyping = typingMap.get(channel);
+      const payload = JSON.stringify({
+        content: contentBlocks,
+        channel,
+        conversationId: body.conversationId,
+        sender: senderName,
+        participants: participantNames,
+        participantCount: participants.length,
+        isDM,
+        ...currentlyTyping.length > 0 ? { typing: currentlyTyping } : {}
+      });
+      daemonFetchInternal(`/api/minds/${encodeURIComponent(mindName)}/message`, payload).then(async (res) => {
+        if (!res.ok) {
+          const text = await res.text().catch(() => "");
+          console.error(`[chat] mind ${mindName} responded ${res.status}: ${text}`);
+        }
+      }).catch((err) => {
+        console.error(`[chat] mind ${mindName} unreachable via daemon:`, err);
+      });
+    }
+    return c.json({ ok: true, conversationId: body.conversationId });
+  }
+);
+var chat_default = app18;
 
 // src/web/api/volute/conversations.ts
-import { zValidator as zValidator5 } from "@hono/zod-validator";
-import { Hono as Hono15 } from "hono";
-import { z as z5 } from "zod";
-var createConvSchema = z5.object({
-  title: z5.string().optional(),
-  participantIds: z5.array(z5.number()).optional(),
-  participantNames: z5.array(z5.string()).optional()
+import { zValidator as zValidator8 } from "@hono/zod-validator";
+import { Hono as Hono19 } from "hono";
+import { z as z8 } from "zod";
+var createConvSchema = z8.object({
+  title: z8.string().optional(),
+  participantIds: z8.array(z8.number()).optional(),
+  participantNames: z8.array(z8.string()).optional()
 });
-var app15 = new Hono15().get("/:name/conversations", async (c) => {
+var app19 = new Hono19().get("/:name/conversations", async (c) => {
   const name = c.req.param("name");
   const user = c.get("user");
   let lookupId = user.id;
@@ -4275,9 +4894,9 @@ var app15 = new Hono15().get("/:name/conversations", async (c) => {
     lookupId = mindUser.id;
   }
   const all = await listConversationsForUser(lookupId);
-  const convs = all.filter((c2) => c2.mind_name === name);
+  const convs = all.filter((c2) => c2.mind_name === name || c2.type === "channel");
   return c.json(convs);
-}).post("/:name/conversations", zValidator5("json", createConvSchema), async (c) => {
+}).post("/:name/conversations", zValidator8("json", createConvSchema), async (c) => {
   const name = c.req.param("name");
   const user = c.get("user");
   const body = c.req.valid("json");
@@ -4351,17 +4970,18 @@ var app15 = new Hono15().get("/:name/conversations", async (c) => {
   if (!deleted) return c.json({ error: "Conversation not found" }, 404);
   return c.json({ ok: true });
 });
-var conversations_default = app15;
+var conversations_default = app19;
 
 // src/web/api/volute/user-conversations.ts
-import { zValidator as zValidator6 } from "@hono/zod-validator";
-import { Hono as Hono16 } from "hono";
-import { z as z6 } from "zod";
-var createSchema = z6.object({
-  title: z6.string().optional(),
-  participantNames: z6.array(z6.string()).min(1)
+import { zValidator as zValidator9 } from "@hono/zod-validator";
+import { Hono as Hono20 } from "hono";
+import { streamSSE as streamSSE4 } from "hono/streaming";
+import { z as z9 } from "zod";
+var createSchema2 = z9.object({
+  title: z9.string().optional(),
+  participantNames: z9.array(z9.string()).min(1)
 });
-var app16 = new Hono16().use("*", authMiddleware).get("/", async (c) => {
+var app20 = new Hono20().use("*", authMiddleware).get("/", async (c) => {
   const user = c.get("user");
   const convs = await listConversationsWithParticipants(user.id);
   return c.json(convs);
@@ -4373,7 +4993,7 @@ var app16 = new Hono16().use("*", authMiddleware).get("/", async (c) => {
   }
   const msgs = await getMessages(id);
   return c.json(msgs);
-}).post("/", zValidator6("json", createSchema), async (c) => {
+}).post("/", zValidator9("json", createSchema2), async (c) => {
   const user = c.get("user");
   const body = c.req.valid("json");
   const participantIds = /* @__PURE__ */ new Set();
@@ -4403,6 +5023,31 @@ var app16 = new Hono16().use("*", authMiddleware).get("/", async (c) => {
     participantIds: [...participantIds]
   });
   return c.json(conv, 201);
+}).get("/:id/events", async (c) => {
+  const conversationId = c.req.param("id");
+  const user = c.get("user");
+  if (user.id !== 0 && !await isParticipantOrOwner(conversationId, user.id)) {
+    return c.json({ error: "Conversation not found" }, 404);
+  }
+  return streamSSE4(c, async (stream) => {
+    const unsubscribe = subscribe(conversationId, (event) => {
+      stream.writeSSE({ data: JSON.stringify(event) }).catch((err) => {
+        if (!stream.aborted) console.error("[chat] SSE write error:", err);
+      });
+    });
+    const keepAlive = setInterval(() => {
+      stream.writeSSE({ data: "" }).catch((err) => {
+        if (!stream.aborted) console.error("[chat] SSE ping error:", err);
+      });
+    }, 15e3);
+    await new Promise((resolve19) => {
+      stream.onAbort(() => {
+        unsubscribe();
+        clearInterval(keepAlive);
+        resolve19();
+      });
+    });
+  });
 }).delete("/:id", async (c) => {
   const id = c.req.param("id");
   const user = c.get("user");
@@ -4410,12 +5055,12 @@ var app16 = new Hono16().use("*", authMiddleware).get("/", async (c) => {
   if (!deleted) return c.json({ error: "Conversation not found" }, 404);
   return c.json({ ok: true });
 });
-var user_conversations_default = app16;
+var user_conversations_default = app20;
 
 // src/web/app.ts
 var httpLog = logger_default.child("http");
-var app17 = new Hono17();
-app17.onError((err, c) => {
+var app21 = new Hono21();
+app21.onError((err, c) => {
   if (err instanceof HTTPException) {
     return err.getResponse();
   }
@@ -4426,10 +5071,10 @@ app17.onError((err, c) => {
   });
   return c.json({ error: "Internal server error" }, 500);
 });
-app17.notFound((c) => {
+app21.notFound((c) => {
   return c.json({ error: "Not found" }, 404);
 });
-app17.use("*", async (c, next) => {
+app21.use("*", async (c, next) => {
   const start = Date.now();
   await next();
   const duration = Date.now() - start;
@@ -4440,7 +5085,7 @@ app17.use("*", async (c, next) => {
     httpLog.debug("request", data);
   }
 });
-app17.get("/api/health", (c) => {
+app21.get("/api/health", (c) => {
   let version = "unknown";
   let cached = null;
   try {
@@ -4455,15 +5100,18 @@ app17.get("/api/health", (c) => {
     ...cached?.updateAvailable ? { updateAvailable: true, latest: cached.latest } : {}
   });
 });
-app17.use("/api/*", bodyLimit({ maxSize: 10 * 1024 * 1024 }));
-app17.use("/api/*", csrf());
-app17.use("/api/minds/*", authMiddleware);
-app17.use("/api/conversations/*", authMiddleware);
-app17.use("/api/system/*", authMiddleware);
-app17.use("/api/env/*", authMiddleware);
-app17.route("/pages", pages_default);
-var routes = app17.route("/api/auth", auth_default).route("/api/system", system_default).route("/api/system", update_default).route("/api/minds", minds_default).route("/api/minds", chat_default).route("/api/minds", connectors_default).route("/api/minds", schedules_default).route("/api/minds", logs_default).route("/api/minds", typing_default).route("/api/minds", variants_default).route("/api/minds", files_default).route("/api/minds", channels_default).route("/api/minds", env_default).route("/api/minds", conversations_default).route("/api/env", sharedEnvApp).route("/api/conversations", user_conversations_default);
-var app_default = app17;
+app21.use("/api/*", bodyLimit({ maxSize: 10 * 1024 * 1024 }));
+app21.use("/api/*", csrf());
+app21.use("/api/minds/*", authMiddleware);
+app21.use("/api/conversations/*", authMiddleware);
+app21.use("/api/volute/*", authMiddleware);
+app21.use("/api/system/*", authMiddleware);
+app21.use("/api/env/*", authMiddleware);
+app21.use("/api/prompts/*", authMiddleware);
+app21.use("/api/skills/*", authMiddleware);
+app21.route("/pages", pages_default);
+var routes = app21.route("/api/auth", auth_default).route("/api/system", system_default).route("/api/system", update_default).route("/api/minds", minds_default).route("/api/minds", chat_default).route("/api/minds", connectors_default).route("/api/minds", schedules_default).route("/api/minds", logs_default).route("/api/minds", typing_default).route("/api/minds", variants_default).route("/api/minds", files_default).route("/api/minds", channels_default).route("/api/minds", env_default).route("/api/minds", mind_skills_default).route("/api/minds", conversations_default).route("/api/env", sharedEnvApp).route("/api/prompts", prompts_default).route("/api/skills", skills_default).route("/api/conversations", user_conversations_default).route("/api/volute/channels", channels_default2).route("/api/volute", unifiedChatApp);
+var app_default = app21;
 
 // src/web/server.ts
 var MIME_TYPES2 = {
@@ -4480,20 +5128,20 @@ async function startServer({
   hostname = "127.0.0.1"
 }) {
   let assetsDir = "";
-  let searchDir = dirname3(new URL(import.meta.url).pathname);
+  let searchDir = dirname2(new URL(import.meta.url).pathname);
   for (let i = 0; i < 5; i++) {
-    const candidate = resolve16(searchDir, "dist", "web-assets");
-    if (existsSync10(candidate)) {
+    const candidate = resolve17(searchDir, "dist", "web-assets");
+    if (existsSync11(candidate)) {
       assetsDir = candidate;
       break;
     }
-    searchDir = dirname3(searchDir);
+    searchDir = dirname2(searchDir);
   }
   if (assetsDir) {
     app_default.get("*", async (c) => {
       const urlPath = new URL(c.req.url).pathname;
       if (urlPath.startsWith("/api/")) return c.notFound();
-      const filePath = resolve16(assetsDir, urlPath.slice(1));
+      const filePath = resolve17(assetsDir, urlPath.slice(1));
       if (!filePath.startsWith(assetsDir)) return c.text("Forbidden", 403);
       const s = await stat2(filePath).catch(() => null);
       if (s?.isFile()) {
@@ -4502,7 +5150,7 @@ async function startServer({
         const body = await readFile3(filePath);
         return c.body(body, 200, { "Content-Type": mime });
       }
-      const indexPath = resolve16(assetsDir, "index.html");
+      const indexPath = resolve17(assetsDir, "index.html");
       const indexStat = await stat2(indexPath).catch(() => null);
       if (indexStat?.isFile()) {
         const body = await readFile3(indexPath, "utf-8");
@@ -4512,10 +5160,10 @@ async function startServer({
     });
   }
   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();
+      resolve19();
     });
     server.on("error", (err) => {
       reject(err);
@@ -4526,14 +5174,14 @@ async function startServer({
 
 // src/daemon.ts
 if (!process.env.VOLUTE_HOME) {
-  process.env.VOLUTE_HOME = resolve17(homedir2(), ".volute");
+  process.env.VOLUTE_HOME = resolve18(homedir2(), ".volute");
 }
 async function startDaemon(opts) {
   const { port, hostname } = opts;
   const myPid = String(process.pid);
   const home = voluteHome();
   if (!opts.foreground) {
-    const rotatingLog = new RotatingLog(resolve17(home, "daemon.log"));
+    const rotatingLog = new RotatingLog(resolve18(home, "daemon.log"));
     logger_default.setOutput((line) => rotatingLog.write(`${line}
 `));
     const write = (...args) => rotatingLog.write(`${format(...args)}
@@ -4543,9 +5191,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");
-  mkdirSync7(home, { recursive: true });
+  const DAEMON_PID_PATH = resolve18(home, "daemon.pid");
+  const DAEMON_JSON_PATH = resolve18(home, "daemon.json");
+  mkdirSync8(home, { recursive: true });
   migrateAgentsToMinds();
   const token = process.env.VOLUTE_DAEMON_TOKEN || randomBytes(32).toString("hex");
   process.env.VOLUTE_DAEMON_TOKEN = token;
@@ -4562,8 +5210,8 @@ async function startDaemon(opts) {
     }
     throw err;
   }
-  writeFileSync7(DAEMON_PID_PATH, myPid, { mode: 420 });
-  writeFileSync7(DAEMON_JSON_PATH, `${JSON.stringify({ port, hostname, token }, null, 2)}
+  writeFileSync8(DAEMON_PID_PATH, myPid, { mode: 420 });
+  writeFileSync8(DAEMON_JSON_PATH, `${JSON.stringify({ port, hostname, token }, null, 2)}
 `, {
     mode: 420
   });
@@ -4622,13 +5270,13 @@ async function startDaemon(opts) {
   logger_default.info(`running on ${hostname}:${port}, pid ${myPid}`);
   function cleanup() {
     try {
-      if (readFileSync9(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
+      if (readFileSync10(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
         unlinkSync2(DAEMON_PID_PATH);
       }
     } catch {
     }
     try {
-      const data = JSON.parse(readFileSync9(DAEMON_JSON_PATH, "utf-8"));
+      const data = JSON.parse(readFileSync10(DAEMON_JSON_PATH, "utf-8"));
       if (data.token === token) {
         unlinkSync2(DAEMON_JSON_PATH);
       }