volute 0.24.0 → 0.26.0

package/dist/{chunk-OOW675I3.js → chunk-3CFRE2VC.js}

@@ -4,26 +4,26 @@ import {
 } from "./chunk-HFCBO2GL.js";
 import {
   markIdle
-} from "./chunk-E7GOKNOT.js";
+} from "./chunk-NWI2425I.js";
 import {
+  broadcast,
   publish,
   subscribe
-} from "./chunk-BFK6SOEJ.js";
+} from "./chunk-J2CO4WEV.js";
 import {
   RestartTracker,
   RotatingLog,
   clearJsonMap,
   getMindManager,
+  getMindToken,
   getPrompt,
   loadJsonMap,
   saveJsonMap
-} from "./chunk-NOBRGACV.js";
+} from "./chunk-2VO7453N.js";
 import {
-  readVoluteConfig
-} from "./chunk-XLC342FO.js";
-import {
-  loadMergedEnv
-} from "./chunk-PHU4DEAJ.js";
+  isSandboxEnabled,
+  wrapForSandbox
+} from "./chunk-UTL75LP6.js";
 import {
   conversationParticipants,
   conversationReads,
@@ -33,18 +33,24 @@ import {
   messages,
   mindHistory,
   users
-} from "./chunk-33XAVCS4.js";
+} from "./chunk-WBHMQ5OZ.js";
 import {
   logger_default
 } from "./chunk-YUIHSKR6.js";
+import {
+  readVoluteConfig
+} from "./chunk-SIAG3QMM.js";
+import {
+  loadMergedEnv
+} from "./chunk-PHU4DEAJ.js";
 import {
   exec
-} from "./chunk-JTDFJWI2.js";
+} from "./chunk-YJA7P64S.js";
 import {
   chownMindDir,
   isIsolationEnabled,
   wrapForIsolation
-} from "./chunk-NWPT4ASZ.js";
+} from "./chunk-XOXLRRR2.js";
 import {
   daemonLoopback,
   findMind,
@@ -56,7 +62,7 @@ import {
 } from "./chunk-B2CPS4QU.js";
 
 // src/lib/daemon/sleep-manager.ts
-import { execFile } from "child_process";
+import { execFile, spawn as spawnChild } from "child_process";
 import {
   existsSync as existsSync5,
   mkdirSync as mkdirSync3,
@@ -69,11 +75,11 @@ import {
 import { resolve as resolve8 } from "path";
 import { promisify } from "util";
 import { CronExpressionParser as CronExpressionParser2 } from "cron-parser";
-import { and as and4, eq as eq4, inArray as inArray2 } from "drizzle-orm";
+import { and as and4, eq as eq4, inArray as inArray3 } from "drizzle-orm";
 
 // src/lib/auth.ts
 import { compareSync, hashSync } from "bcryptjs";
-import { and, count, eq } from "drizzle-orm";
+import { and, count, eq, inArray } from "drizzle-orm";
 var userSelectFields = {
   id: users.id,
   username: users.username,
@@ -131,7 +137,7 @@ async function getOrCreateMindUser(mindName) {
     const [result] = await db.insert(users).values({
       username: mindName,
       password_hash: "!mind",
-      role: "mind",
+      role: "user",
       user_type: "mind"
     }).returning(userSelectFields);
     return result;
@@ -185,12 +191,20 @@ async function updateUserProfile(userId, profile) {
 }
 async function syncMindProfile(mindName, config) {
   const user = await getOrCreateMindUser(mindName);
-  const db = await getDb();
-  await db.update(users).set({
+  const newProfile = {
     display_name: config.displayName ?? null,
     description: config.description ?? null,
     avatar: config.avatar ?? null
-  }).where(eq(users.id, user.id));
+  };
+  const changed = user.display_name !== newProfile.display_name || user.description !== newProfile.description || user.avatar !== newProfile.avatar;
+  if (!changed) return;
+  const db = await getDb();
+  await db.update(users).set(newProfile).where(eq(users.id, user.id));
+  broadcast({ type: "profile_updated", mind: mindName, summary: `${mindName} profile updated` });
+}
+async function migrateMindRoles() {
+  const db = await getDb();
+  await db.update(users).set({ role: "user" }).where(and(eq(users.user_type, "mind"), inArray(users.role, ["mind", "agent"])));
 }
 
 // src/lib/pages-watcher.ts
@@ -231,16 +245,16 @@ function startPagesWatcher(mindName, pagesDir) {
 }
 function startWatcher(mindName) {
   if (watchers.has(mindName)) return;
-  const pagesDir = resolve(mindDir(mindName), "home", "pages");
+  const pagesDir = resolve(mindDir(mindName), "home", "public", "pages");
   if (existsSync(pagesDir)) {
     startPagesWatcher(mindName, pagesDir);
     return;
   }
   if (homeWatchers.has(mindName)) return;
-  const homeDir = resolve(mindDir(mindName), "home");
-  if (!existsSync(homeDir)) return;
+  const publicDir = resolve(mindDir(mindName), "home", "public");
+  if (!existsSync(publicDir)) return;
   try {
-    const hw = watch(homeDir, (_eventType, filename) => {
+    const hw = watch(publicDir, (_eventType, filename) => {
       if (filename !== "pages") return;
       if (!existsSync(pagesDir)) return;
       hw.close();
@@ -337,7 +351,7 @@ function buildSites() {
   }
   const entries = readRegistry();
   for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
-    const pagesDir = resolve(mindDir(entry.name), "home", "pages");
+    const pagesDir = resolve(mindDir(entry.name), "home", "public", "pages");
     if (!existsSync(pagesDir)) continue;
     const mindPages = scanPagesDir(pagesDir, `/pages/${entry.name}`);
     if (mindPages.length > 0) {
@@ -350,7 +364,7 @@ function buildRecentPages() {
   const entries = readRegistry();
   const pages = [];
   for (const entry of entries) {
-    const pagesDir = resolve(mindDir(entry.name), "home", "pages");
+    const pagesDir = resolve(mindDir(entry.name), "home", "public", "pages");
     if (!existsSync(pagesDir)) continue;
     let items;
     try {
@@ -398,159 +412,605 @@ function getCachedRecentPages() {
   return recentPagesCache;
 }
 
-// src/lib/daemon/connector-manager.ts
-import { spawn } from "child_process";
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
-import { dirname, resolve as resolve3 } from "path";
+// src/lib/events/conversations.ts
+import { randomUUID } from "crypto";
+import { and as and2, desc, eq as eq2, inArray as inArray2, isNull, lt, sql } from "drizzle-orm";
 
-// src/lib/connector-defs.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { resolve as resolve2 } from "path";
-var BUILTIN_DEFS = {
-  discord: {
-    displayName: "Discord",
-    description: "Connect to Discord as a bot",
-    envVars: [
-      {
-        name: "DISCORD_TOKEN",
-        required: true,
-        description: "Discord bot token",
-        scope: "mind"
-      },
-      {
-        name: "DISCORD_GUILD_ID",
-        required: false,
-        description: "Discord server ID (optional, for slash commands)",
-        scope: "mind"
-      }
-    ]
-  },
-  slack: {
-    displayName: "Slack",
-    description: "Connect to Slack via Socket Mode",
-    envVars: [
-      {
-        name: "SLACK_BOT_TOKEN",
-        required: true,
-        description: "Slack bot token (xoxb-...)",
-        scope: "mind"
-      },
-      {
-        name: "SLACK_APP_TOKEN",
-        required: true,
-        description: "Slack app-level token (xapp-...) for Socket Mode",
-        scope: "mind"
-      }
-    ]
-  },
-  telegram: {
-    displayName: "Telegram",
-    description: "Connect to Telegram via long polling",
-    envVars: [
-      {
-        name: "TELEGRAM_BOT_TOKEN",
-        required: true,
-        description: "Telegram bot token from BotFather",
-        scope: "mind"
+// src/lib/webhook.ts
+var slog = logger_default.child("webhook");
+function getWebhookUrl() {
+  return process.env.VOLUTE_WEBHOOK_URL;
+}
+function getAuthHeaders() {
+  const headers = { "Content-Type": "application/json" };
+  const secret = process.env.VOLUTE_WEBHOOK_SECRET;
+  if (secret) headers.Authorization = `Bearer ${secret}`;
+  return headers;
+}
+function fireWebhook(event) {
+  try {
+    const url = getWebhookUrl();
+    if (!url) return;
+    const payload = { ...event, timestamp: event.timestamp ?? (/* @__PURE__ */ new Date()).toISOString() };
+    fetch(url, {
+      method: "POST",
+      headers: getAuthHeaders(),
+      body: JSON.stringify(payload)
+    }).then((res) => {
+      if (!res.ok) {
+        slog.warn(`webhook ${event.event} returned HTTP ${res.status}`);
       }
-    ]
+    }).catch((err) => {
+      slog.warn(`webhook delivery failed for ${event.event}`, logger_default.errorData(err));
+    });
+  } catch (err) {
+    slog.error(`webhook ${event.event} failed to serialize`, logger_default.errorData(err));
   }
-};
-function getConnectorDef(type, connectorDir) {
-  if (BUILTIN_DEFS[type]) return BUILTIN_DEFS[type];
-  if (connectorDir) {
-    const jsonPath = resolve2(connectorDir, "connector.json");
-    if (existsSync2(jsonPath)) {
-      try {
-        return JSON.parse(readFileSync(jsonPath, "utf-8"));
-      } catch (err) {
-        console.warn(`Failed to parse ${jsonPath}: ${err}`);
-        return null;
-      }
+}
+function initWebhook() {
+  const url = getWebhookUrl();
+  if (!url) return () => {
+  };
+  try {
+    const parsed = new URL(url);
+    if (!["http:", "https:"].includes(parsed.protocol)) {
+      slog.error(`VOLUTE_WEBHOOK_URL has unsupported protocol: ${parsed.protocol}`);
+      return () => {
+      };
     }
+  } catch {
+    slog.error(`VOLUTE_WEBHOOK_URL is not a valid URL`);
+    return () => {
+    };
   }
-  return null;
-}
-function checkMissingEnvVars(def, env) {
-  return def.envVars.filter((v) => v.required && !env[v.name]);
+  slog.info("webhook enabled");
+  return subscribe((event) => {
+    try {
+      fireWebhook({
+        event: event.type,
+        mind: event.mind,
+        data: { summary: event.summary, ...event.metadata },
+        timestamp: event.created_at
+      });
+    } catch (err) {
+      slog.error(`failed to fire webhook for ${event.type}`, logger_default.errorData(err));
+    }
+  });
 }
 
-// src/lib/daemon/connector-manager.ts
-var clog = logger_default.child("connectors");
-function searchUpwards(...segments) {
-  let searchDir = dirname(new URL(import.meta.url).pathname);
-  for (let i = 0; i < 5; i++) {
-    const candidate = resolve3(searchDir, ...segments);
-    if (existsSync3(candidate)) return candidate;
-    searchDir = dirname(searchDir);
+// src/lib/events/conversation-events.ts
+var subscribers = /* @__PURE__ */ new Map();
+function subscribe2(conversationId, callback) {
+  let set = subscribers.get(conversationId);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    subscribers.set(conversationId, set);
   }
-  return null;
+  set.add(callback);
+  return () => {
+    set.delete(callback);
+    if (set.size === 0) subscribers.delete(conversationId);
+  };
 }
-var ConnectorManager = class {
-  connectors = /* @__PURE__ */ new Map();
-  stopping = /* @__PURE__ */ new Set();
-  // "mind:type" keys currently being explicitly stopped
-  shuttingDown = false;
-  restartTracker = new RestartTracker();
-  async startConnectors(mindName, mindDir2, mindPort, daemonPort) {
-    const config = readVoluteConfig(mindDir2) ?? {};
-    const types = config.connectors ?? [];
-    await Promise.all(
-      types.map(
-        (type) => this.startConnector(mindName, mindDir2, mindPort, type, daemonPort).catch((err) => {
-          clog.warn(`failed to start connector ${type} for ${mindName}`, logger_default.errorData(err));
-        })
-      )
-    );
-  }
-  checkConnectorEnv(type, mindName, mindDir2) {
-    const mindConnectorDir = resolve3(mindDir2, "connectors", type);
-    const userConnectorDir = resolve3(voluteHome(), "connectors", type);
-    const connectorDir = existsSync3(mindConnectorDir) ? mindConnectorDir : existsSync3(userConnectorDir) ? userConnectorDir : void 0;
-    const def = getConnectorDef(type, connectorDir);
-    if (!def) return null;
-    const env = loadMergedEnv(mindName);
-    const missing = checkMissingEnvVars(def, env);
-    if (missing.length === 0) return null;
-    return {
-      missing: missing.map((v) => ({ name: v.name, description: v.description })),
-      connectorName: def.displayName
-    };
+function publish2(conversationId, event) {
+  const set = subscribers.get(conversationId);
+  if (!set) return;
+  for (const cb of set) {
+    try {
+      cb(event);
+    } catch (err) {
+      console.error("[conversation-events] subscriber threw:", err);
+      set.delete(cb);
+      if (set.size === 0) subscribers.delete(conversationId);
+    }
   }
-  async startConnector(mindName, mindDir2, mindPort, type, daemonPort) {
-    const existing = this.connectors.get(mindName)?.get(type);
-    if (existing) {
-      await new Promise((res) => {
-        existing.child.on("exit", () => res());
-        try {
-          if (existing.child.pid) {
-            process.kill(-existing.child.pid, "SIGTERM");
-          } else {
-            existing.child.kill("SIGTERM");
-          }
-        } catch {
-          res();
-        }
-        setTimeout(() => {
-          try {
-            if (existing.child.pid) {
-              process.kill(-existing.child.pid, "SIGKILL");
-            } else {
-              existing.child.kill("SIGKILL");
-            }
-          } catch {
-          }
-          res();
-        }, 3e3);
-      });
-      this.connectors.get(mindName)?.delete(type);
+}
+
+// src/lib/events/conversations.ts
+async function createConversation(mindName, channel, opts) {
+  const db = await getDb();
+  const id = randomUUID();
+  const type = opts?.type ?? "dm";
+  const name = opts?.name ?? null;
+  await db.transaction(async (tx) => {
+    await tx.insert(conversations).values({
+      id,
+      mind_name: mindName,
+      channel,
+      type,
+      name,
+      user_id: opts?.userId ?? null,
+      title: opts?.title ?? null
+    });
+    if (opts?.participantIds && opts.participantIds.length > 0) {
+      await tx.insert(conversationParticipants).values(
+        opts.participantIds.map((uid, i) => ({
+          conversation_id: id,
+          user_id: uid,
+          role: i === 0 ? "owner" : "member"
+        }))
+      );
     }
-    this.killOrphanConnector(mindName, type);
-    const mindConnector = resolve3(mindDir2, "connectors", type, "index.ts");
-    const userConnector = resolve3(voluteHome(), "connectors", type, "index.ts");
-    const builtinConnector = this.resolveBuiltinConnector(type);
-    let connectorScript;
-    let runtime;
+  });
+  fireWebhook({
+    event: "conversation_created",
+    mind: mindName ?? "",
+    data: { id, mindName, channel, type, name, title: opts?.title ?? null }
+  });
+  return {
+    id,
+    mind_name: mindName,
+    channel,
+    type,
+    name,
+    user_id: opts?.userId ?? null,
+    title: opts?.title ?? null,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function getConversation(id) {
+  const db = await getDb();
+  const row = await db.select().from(conversations).where(eq2(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(
+      eq2(conversationParticipants.conversation_id, conversationId),
+      eq2(conversationParticipants.user_id, userId)
+    )
+  );
+}
+async function getParticipants(conversationId) {
+  const db = await getDb();
+  const rows = await db.select({
+    userId: conversationParticipants.user_id,
+    username: users.username,
+    userType: users.user_type,
+    role: conversationParticipants.role,
+    displayName: users.display_name,
+    description: users.description,
+    avatar: users.avatar
+  }).from(conversationParticipants).innerJoin(users, eq2(conversationParticipants.user_id, users.id)).where(eq2(conversationParticipants.conversation_id, conversationId)).all();
+  return rows;
+}
+async function isParticipant(conversationId, userId) {
+  const db = await getDb();
+  const row = await db.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(
+    and2(
+      eq2(conversationParticipants.conversation_id, conversationId),
+      eq2(conversationParticipants.user_id, userId)
+    )
+  ).get();
+  return row != null;
+}
+async function listConversationsForUser(userId) {
+  const db = await getDb();
+  const participantRows = await db.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(eq2(conversationParticipants.user_id, userId)).all();
+  if (participantRows.length === 0) return [];
+  const convIds = participantRows.map((r) => r.conversation_id);
+  return await db.select().from(conversations).where(inArray2(conversations.id, convIds)).orderBy(desc(conversations.updated_at)).all();
+}
+async function isParticipantOrOwner(conversationId, userId) {
+  if (await isParticipant(conversationId, userId)) return true;
+  const db = await getDb();
+  const row = await db.select().from(conversations).where(and2(eq2(conversations.id, conversationId), eq2(conversations.user_id, userId))).get();
+  return row != null;
+}
+async function deleteConversationForUser(id, userId) {
+  if (!await isParticipantOrOwner(id, userId)) return false;
+  await deleteConversation(id);
+  return true;
+}
+async function addMessage(conversationId, role, senderName, content) {
+  const db = await getDb();
+  const serialized = JSON.stringify(content);
+  const [result] = await db.insert(messages).values({ conversation_id: conversationId, role, sender_name: senderName, content: serialized }).returning({ id: messages.id, created_at: messages.created_at });
+  await db.update(conversations).set({ updated_at: sql`datetime('now')` }).where(eq2(conversations.id, conversationId));
+  if (role === "user") {
+    const firstText = content.find((b) => b.type === "text");
+    const title = firstText ? firstText.text.slice(0, 80) : "";
+    if (title) {
+      await db.update(conversations).set({ title }).where(and2(eq2(conversations.id, conversationId), isNull(conversations.title)));
+    }
+  }
+  const msg = {
+    id: result.id,
+    conversation_id: conversationId,
+    role,
+    sender_name: senderName,
+    content,
+    created_at: result.created_at
+  };
+  publish2(conversationId, {
+    type: "message",
+    id: msg.id,
+    role: msg.role,
+    senderName: msg.sender_name,
+    content: msg.content,
+    createdAt: msg.created_at
+  });
+  const conv = await db.select({ mind_name: conversations.mind_name }).from(conversations).where(eq2(conversations.id, conversationId)).get();
+  fireWebhook({
+    event: "message_created",
+    mind: conv?.mind_name ?? "",
+    data: {
+      conversationId,
+      messageId: result.id,
+      role,
+      senderName,
+      content: content.filter((b) => b.type !== "image"),
+      createdAt: result.created_at
+    }
+  });
+  return msg;
+}
+async function getMessages(conversationId) {
+  const db = await getDb();
+  const rows = await db.select().from(messages).where(eq2(messages.conversation_id, conversationId)).orderBy(messages.created_at).all();
+  return rows.map(parseMessageRow);
+}
+async function getMessagesPaginated(conversationId, opts) {
+  const db = await getDb();
+  const limit = Math.min(Math.max(opts?.limit ?? 50, 1), 100);
+  const conditions = [eq2(messages.conversation_id, conversationId)];
+  if (opts?.before != null) {
+    conditions.push(lt(messages.id, opts.before));
+  }
+  const rows = await db.select().from(messages).where(and2(...conditions)).orderBy(desc(messages.id)).limit(limit + 1).all();
+  const hasMore = rows.length > limit;
+  const page = rows.slice(0, limit).reverse();
+  return {
+    messages: page.map(parseMessageRow),
+    hasMore
+  };
+}
+function parseMessageRow(row) {
+  let content;
+  try {
+    const parsed = JSON.parse(row.content);
+    content = Array.isArray(parsed) ? parsed : [{ type: "text", text: row.content }];
+  } catch {
+    content = [{ type: "text", text: row.content }];
+  }
+  return { ...row, role: row.role, content };
+}
+async function listConversationsWithParticipants(userId) {
+  const convs = await listConversationsForUser(userId);
+  if (convs.length === 0) return [];
+  const db = await getDb();
+  const convIds = convs.map((c) => c.id);
+  const rows = await db.select({
+    conversationId: conversationParticipants.conversation_id,
+    userId: users.id,
+    username: users.username,
+    userType: users.user_type,
+    role: conversationParticipants.role,
+    displayName: users.display_name,
+    description: users.description,
+    avatar: users.avatar
+  }).from(conversationParticipants).innerJoin(users, eq2(conversationParticipants.user_id, users.id)).where(inArray2(conversationParticipants.conversation_id, convIds));
+  const byConv = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    let arr = byConv.get(r.conversationId);
+    if (!arr) {
+      arr = [];
+      byConv.set(r.conversationId, arr);
+    }
+    arr.push({
+      userId: r.userId,
+      username: r.username,
+      userType: r.userType,
+      role: r.role,
+      displayName: r.displayName,
+      description: r.description,
+      avatar: r.avatar
+    });
+  }
+  const lastMsgIds = await db.select({
+    conversationId: messages.conversation_id,
+    maxId: sql`MAX(${messages.id})`
+  }).from(messages).where(inArray2(messages.conversation_id, convIds)).groupBy(messages.conversation_id);
+  const byLastMsg = /* @__PURE__ */ new Map();
+  if (lastMsgIds.length > 0) {
+    const msgRows = await db.select().from(messages).where(
+      inArray2(
+        messages.id,
+        lastMsgIds.map((r) => r.maxId)
+      )
+    );
+    for (const m of msgRows) {
+      let text = "";
+      try {
+        const parsed = JSON.parse(m.content);
+        const blocks = Array.isArray(parsed) ? parsed : [];
+        const textBlock = blocks.find((b) => b.type === "text");
+        if (textBlock && "text" in textBlock) text = textBlock.text;
+      } catch {
+        text = m.content;
+      }
+      byLastMsg.set(m.conversation_id, {
+        role: m.role,
+        senderName: m.sender_name,
+        text,
+        createdAt: m.created_at
+      });
+    }
+  }
+  return convs.map((c) => ({
+    ...c,
+    participants: byConv.get(c.id) ?? [],
+    lastMessage: byLastMsg.get(c.id)
+  }));
+}
+async function findDMConversation(mindName, participantIds) {
+  const db = await getDb();
+  const mindConvs = await db.select({ id: conversations.id }).from(conversations).where(and2(eq2(conversations.mind_name, mindName), eq2(conversations.type, "dm"))).all();
+  for (const conv of mindConvs) {
+    const rows = await db.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(eq2(conversationParticipants.conversation_id, conv.id)).all();
+    if (rows.length !== 2) continue;
+    const ids = new Set(rows.map((r) => r.user_id));
+    if (ids.has(participantIds[0]) && ids.has(participantIds[1])) {
+      return conv.id;
+    }
+  }
+  return null;
+}
+async function deleteConversation(id) {
+  const db = await getDb();
+  await db.delete(conversations).where(eq2(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(eq2(conversations.name, name), eq2(conversations.type, "channel"))).get();
+  return row ?? null;
+}
+async function listChannels() {
+  const db = await getDb();
+  return await db.select().from(conversations).where(eq2(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);
+}
+async function getUnreadCounts(userId, conversationIds) {
+  if (conversationIds.length === 0) return {};
+  const db = await getDb();
+  const rows = await db.select({
+    conversationId: messages.conversation_id,
+    count: sql`COUNT(*)`
+  }).from(messages).leftJoin(
+    conversationReads,
+    and2(
+      eq2(conversationReads.conversation_id, messages.conversation_id),
+      eq2(conversationReads.user_id, userId)
+    )
+  ).where(
+    and2(
+      inArray2(messages.conversation_id, conversationIds),
+      sql`${messages.id} > COALESCE(${conversationReads.last_read_message_id}, 0)`
+    )
+  ).groupBy(messages.conversation_id);
+  const result = {};
+  for (const row of rows) {
+    result[row.conversationId] = row.count;
+  }
+  return result;
+}
+async function markConversationRead(userId, conversationId) {
+  const db = await getDb();
+  const maxRow = await db.select({ maxId: sql`MAX(${messages.id})` }).from(messages).where(eq2(messages.conversation_id, conversationId)).get();
+  const maxId = maxRow?.maxId ?? 0;
+  if (maxId === 0) return;
+  await db.insert(conversationReads).values({ user_id: userId, conversation_id: conversationId, last_read_message_id: maxId }).onConflictDoUpdate({
+    target: [conversationReads.user_id, conversationReads.conversation_id],
+    set: { last_read_message_id: maxId }
+  });
+}
+
+// src/lib/system-channel.ts
+var SYSTEM_CHANNEL_NAME = "system";
+var cachedChannelId = null;
+async function ensureSystemChannel() {
+  if (cachedChannelId) return cachedChannelId;
+  const existing = await getChannelByName(SYSTEM_CHANNEL_NAME);
+  if (existing) {
+    cachedChannelId = existing.id;
+    return existing.id;
+  }
+  const conv = await createChannel(SYSTEM_CHANNEL_NAME);
+  cachedChannelId = conv.id;
+  logger_default.info("created #system channel");
+  return conv.id;
+}
+async function joinSystemChannel(userId) {
+  const channelId = await ensureSystemChannel();
+  await joinChannel(channelId, userId);
+}
+async function joinSystemChannelForMind(mindName) {
+  const user = await getOrCreateMindUser(mindName);
+  await joinSystemChannel(user.id);
+}
+async function announceToSystem(text) {
+  const channelId = await ensureSystemChannel();
+  await addMessage(channelId, "system", "system", [{ type: "text", text }]);
+}
+
+// src/lib/daemon/connector-manager.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
+import { dirname, resolve as resolve3 } from "path";
+
+// src/lib/connector-defs.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { resolve as resolve2 } from "path";
+var BUILTIN_DEFS = {
+  discord: {
+    displayName: "Discord",
+    description: "Connect to Discord as a bot",
+    envVars: [
+      {
+        name: "DISCORD_TOKEN",
+        required: true,
+        description: "Discord bot token",
+        scope: "mind"
+      },
+      {
+        name: "DISCORD_GUILD_ID",
+        required: false,
+        description: "Discord server ID (optional, for slash commands)",
+        scope: "mind"
+      }
+    ]
+  },
+  slack: {
+    displayName: "Slack",
+    description: "Connect to Slack via Socket Mode",
+    envVars: [
+      {
+        name: "SLACK_BOT_TOKEN",
+        required: true,
+        description: "Slack bot token (xoxb-...)",
+        scope: "mind"
+      },
+      {
+        name: "SLACK_APP_TOKEN",
+        required: true,
+        description: "Slack app-level token (xapp-...) for Socket Mode",
+        scope: "mind"
+      }
+    ]
+  },
+  telegram: {
+    displayName: "Telegram",
+    description: "Connect to Telegram via long polling",
+    envVars: [
+      {
+        name: "TELEGRAM_BOT_TOKEN",
+        required: true,
+        description: "Telegram bot token from BotFather",
+        scope: "mind"
+      }
+    ]
+  }
+};
+function getConnectorDef(type, connectorDir) {
+  if (BUILTIN_DEFS[type]) return BUILTIN_DEFS[type];
+  if (connectorDir) {
+    const jsonPath = resolve2(connectorDir, "connector.json");
+    if (existsSync2(jsonPath)) {
+      try {
+        return JSON.parse(readFileSync(jsonPath, "utf-8"));
+      } catch (err) {
+        console.warn(`Failed to parse ${jsonPath}: ${err}`);
+        return null;
+      }
+    }
+  }
+  return null;
+}
+function checkMissingEnvVars(def, env) {
+  return def.envVars.filter((v) => v.required && !env[v.name]);
+}
+
+// src/lib/daemon/connector-manager.ts
+var clog = logger_default.child("connectors");
+function searchUpwards(...segments) {
+  let searchDir = dirname(new URL(import.meta.url).pathname);
+  for (let i = 0; i < 5; i++) {
+    const candidate = resolve3(searchDir, ...segments);
+    if (existsSync3(candidate)) return candidate;
+    searchDir = dirname(searchDir);
+  }
+  return null;
+}
+var ConnectorManager = class {
+  connectors = /* @__PURE__ */ new Map();
+  stopping = /* @__PURE__ */ new Set();
+  // "mind:type" keys currently being explicitly stopped
+  shuttingDown = false;
+  restartTracker = new RestartTracker();
+  async startConnectors(mindName, mindDir2, mindPort, daemonPort) {
+    const config = readVoluteConfig(mindDir2) ?? {};
+    const types = config.connectors ?? [];
+    await Promise.all(
+      types.map(
+        (type) => this.startConnector(mindName, mindDir2, mindPort, type, daemonPort).catch((err) => {
+          clog.warn(`failed to start connector ${type} for ${mindName}`, logger_default.errorData(err));
+        })
+      )
+    );
+  }
+  checkConnectorEnv(type, mindName, mindDir2) {
+    const mindConnectorDir = resolve3(mindDir2, "connectors", type);
+    const userConnectorDir = resolve3(voluteHome(), "connectors", type);
+    const connectorDir = existsSync3(mindConnectorDir) ? mindConnectorDir : existsSync3(userConnectorDir) ? userConnectorDir : void 0;
+    const def = getConnectorDef(type, connectorDir);
+    if (!def) return null;
+    const env = loadMergedEnv(mindName);
+    const missing = checkMissingEnvVars(def, env);
+    if (missing.length === 0) return null;
+    return {
+      missing: missing.map((v) => ({ name: v.name, description: v.description })),
+      connectorName: def.displayName
+    };
+  }
+  async startConnector(mindName, mindDir2, mindPort, type, daemonPort) {
+    const existing = this.connectors.get(mindName)?.get(type);
+    if (existing) {
+      await new Promise((res) => {
+        existing.child.on("exit", () => res());
+        try {
+          if (existing.child.pid) {
+            process.kill(-existing.child.pid, "SIGTERM");
+          } else {
+            existing.child.kill("SIGTERM");
+          }
+        } catch {
+          res();
+        }
+        setTimeout(() => {
+          try {
+            if (existing.child.pid) {
+              process.kill(-existing.child.pid, "SIGKILL");
+            } else {
+              existing.child.kill("SIGKILL");
+            }
+          } catch {
+          }
+          res();
+        }, 3e3);
+      });
+      this.connectors.get(mindName)?.delete(type);
+    }
+    this.killOrphanConnector(mindName, type);
+    const mindConnector = resolve3(mindDir2, "connectors", type, "index.ts");
+    const userConnector = resolve3(voluteHome(), "connectors", type, "index.ts");
+    const builtinConnector = this.resolveBuiltinConnector(type);
+    let connectorScript;
+    let runtime;
     if (existsSync3(mindConnector)) {
       connectorScript = mindConnector;
       runtime = resolve3(mindDir2, "node_modules", ".bin", "tsx");
@@ -592,12 +1052,24 @@ var ConnectorManager = class {
         VOLUTE_MIND_DIR: mindDir2,
         ...daemonPort ? {
           VOLUTE_DAEMON_URL: `http://${daemonLoopback()}:${daemonPort}`,
-          VOLUTE_DAEMON_TOKEN: process.env.VOLUTE_DAEMON_TOKEN
+          VOLUTE_DAEMON_TOKEN: getMindToken(mindName) ?? void 0
         } : {},
         ...connectorEnv
       }
     };
-    const [spawnCmd, spawnArgs] = wrapForIsolation(runtime, [connectorScript], mindName);
+    let spawnCmd;
+    let spawnArgs;
+    if (isIsolationEnabled()) {
+      [spawnCmd, spawnArgs] = wrapForIsolation(runtime, [connectorScript], mindName);
+    } else if (isSandboxEnabled()) {
+      [spawnCmd, spawnArgs] = await wrapForSandbox(runtime, [connectorScript], mindDir2, mindName, [
+        mindDir2,
+        mindStateDir
+      ]);
+    } else {
+      spawnCmd = runtime;
+      spawnArgs = [connectorScript];
+    }
     const child = spawn(spawnCmd, spawnArgs, spawnOpts);
     let lastStderr = "";
     child.stdout?.pipe(logStream);
@@ -644,558 +1116,140 @@ var ConnectorManager = class {
     const mindMap = this.connectors.get(mindName);
     if (!mindMap) return;
     const tracked = mindMap.get(type);
-    if (!tracked) return;
-    const stopKey = `${mindName}:${type}`;
-    this.stopping.add(stopKey);
-    mindMap.delete(type);
-    await new Promise((resolve9) => {
-      tracked.child.on("exit", () => resolve9());
-      try {
-        process.kill(-tracked.child.pid, "SIGTERM");
-      } catch {
-        resolve9();
-      }
-      setTimeout(() => {
-        try {
-          process.kill(-tracked.child.pid, "SIGKILL");
-        } catch {
-        }
-        resolve9();
-      }, 5e3);
-    });
-    this.stopping.delete(stopKey);
-    this.restartTracker.reset(stopKey);
-    try {
-      this.removeConnectorPid(mindName, type);
-    } catch (err) {
-      clog.warn(`failed to remove PID file for ${type}/${mindName}`, logger_default.errorData(err));
-    }
-    clog.info(`stopped connector ${type} for ${mindName}`);
-  }
-  async stopConnectors(mindName) {
-    const mindMap = this.connectors.get(mindName);
-    if (!mindMap) return;
-    const types = [...mindMap.keys()];
-    await Promise.all(types.map((type) => this.stopConnector(mindName, type)));
-    this.connectors.delete(mindName);
-  }
-  async stopAll() {
-    this.shuttingDown = true;
-    const minds = [...this.connectors.keys()];
-    await Promise.all(minds.map((name) => this.stopConnectors(name)));
-  }
-  getConnectorStatus(mindName) {
-    const mindMap = this.connectors.get(mindName);
-    if (!mindMap) return [];
-    return [...mindMap.entries()].map(([type, tracked]) => ({
-      type,
-      running: !tracked.child.killed
-    }));
-  }
-  connectorPidPath(mindName, type) {
-    return resolve3(stateDir(mindName), "connectors", `${type}.pid`);
-  }
-  saveConnectorPid(mindName, type, pid) {
-    const pidPath = this.connectorPidPath(mindName, type);
-    mkdirSync(dirname(pidPath), { recursive: true });
-    writeFileSync(pidPath, String(pid));
-  }
-  removeConnectorPid(mindName, type) {
-    try {
-      unlinkSync(this.connectorPidPath(mindName, type));
-    } catch {
-    }
-  }
-  killOrphanConnector(mindName, type) {
-    const pidPath = this.connectorPidPath(mindName, type);
-    if (!existsSync3(pidPath)) return;
-    try {
-      const pid = parseInt(readFileSync2(pidPath, "utf-8").trim(), 10);
-      if (pid > 0) {
-        try {
-          process.kill(-pid, "SIGTERM");
-        } catch {
-          process.kill(pid, "SIGTERM");
-        }
-        clog.warn(`killed orphan connector ${type} (pid ${pid})`);
-      }
-    } catch {
-    }
-    try {
-      unlinkSync(pidPath);
-    } catch {
-    }
-  }
-  resolveBuiltinConnector(type) {
-    return searchUpwards("connectors", `${type}.js`);
-  }
-  resolveVoluteTsx() {
-    return searchUpwards("node_modules", ".bin", "tsx") ?? "tsx";
-  }
-};
-var instance = null;
-function initConnectorManager() {
-  if (instance) throw new Error("ConnectorManager already initialized");
-  instance = new ConnectorManager();
-  return instance;
-}
-function getConnectorManager() {
-  if (!instance)
-    throw new Error("ConnectorManager not initialized \u2014 call initConnectorManager() first");
-  return instance;
-}
-
-// src/lib/events/mind-events.ts
-var subscribers = /* @__PURE__ */ new Map();
-function subscribe2(mind, callback) {
-  let set = subscribers.get(mind);
-  if (!set) {
-    set = /* @__PURE__ */ new Set();
-    subscribers.set(mind, set);
-  }
-  set.add(callback);
-  return () => {
-    set.delete(callback);
-    if (set.size === 0) subscribers.delete(mind);
-  };
-}
-function publish2(mind, event) {
-  const set = subscribers.get(mind);
-  if (!set) return;
-  for (const cb of set) {
-    try {
-      cb(event);
-    } catch (err) {
-      console.error("[mind-events] subscriber threw:", err);
-      set.delete(cb);
-      if (set.size === 0) subscribers.delete(mind);
-    }
-  }
-}
-
-// src/lib/delivery/delivery-manager.ts
-import { readFile } from "fs/promises";
-import { extname, resolve as resolve5 } from "path";
-import { and as and3, eq as eq3, sql as sql2 } from "drizzle-orm";
-
-// src/lib/events/conversations.ts
-import { randomUUID } from "crypto";
-import { and as and2, desc, eq as eq2, inArray, isNull, lt, sql } from "drizzle-orm";
-
-// src/lib/webhook.ts
-var slog = logger_default.child("webhook");
-function getWebhookUrl() {
-  return process.env.VOLUTE_WEBHOOK_URL;
-}
-function getAuthHeaders() {
-  const headers = { "Content-Type": "application/json" };
-  const secret = process.env.VOLUTE_WEBHOOK_SECRET;
-  if (secret) headers.Authorization = `Bearer ${secret}`;
-  return headers;
-}
-function fireWebhook(event) {
-  try {
-    const url = getWebhookUrl();
-    if (!url) return;
-    const payload = { ...event, timestamp: event.timestamp ?? (/* @__PURE__ */ new Date()).toISOString() };
-    fetch(url, {
-      method: "POST",
-      headers: getAuthHeaders(),
-      body: JSON.stringify(payload)
-    }).then((res) => {
-      if (!res.ok) {
-        slog.warn(`webhook ${event.event} returned HTTP ${res.status}`);
-      }
-    }).catch((err) => {
-      slog.warn(`webhook delivery failed for ${event.event}`, logger_default.errorData(err));
-    });
-  } catch (err) {
-    slog.error(`webhook ${event.event} failed to serialize`, logger_default.errorData(err));
-  }
-}
-function initWebhook() {
-  const url = getWebhookUrl();
-  if (!url) return () => {
-  };
-  try {
-    const parsed = new URL(url);
-    if (!["http:", "https:"].includes(parsed.protocol)) {
-      slog.error(`VOLUTE_WEBHOOK_URL has unsupported protocol: ${parsed.protocol}`);
-      return () => {
-      };
-    }
-  } catch {
-    slog.error(`VOLUTE_WEBHOOK_URL is not a valid URL`);
-    return () => {
-    };
-  }
-  slog.info("webhook enabled");
-  return subscribe((event) => {
-    try {
-      fireWebhook({
-        event: event.type,
-        mind: event.mind,
-        data: { summary: event.summary, ...event.metadata },
-        timestamp: event.created_at
-      });
-    } catch (err) {
-      slog.error(`failed to fire webhook for ${event.type}`, logger_default.errorData(err));
-    }
-  });
-}
-
-// src/lib/events/conversation-events.ts
-var subscribers2 = /* @__PURE__ */ new Map();
-function subscribe3(conversationId, callback) {
-  let set = subscribers2.get(conversationId);
-  if (!set) {
-    set = /* @__PURE__ */ new Set();
-    subscribers2.set(conversationId, set);
-  }
-  set.add(callback);
-  return () => {
-    set.delete(callback);
-    if (set.size === 0) subscribers2.delete(conversationId);
-  };
-}
-function publish3(conversationId, event) {
-  const set = subscribers2.get(conversationId);
-  if (!set) return;
-  for (const cb of set) {
+    if (!tracked) return;
+    const stopKey = `${mindName}:${type}`;
+    this.stopping.add(stopKey);
+    mindMap.delete(type);
+    await new Promise((resolve9) => {
+      tracked.child.on("exit", () => resolve9());
+      try {
+        process.kill(-tracked.child.pid, "SIGTERM");
+      } catch {
+        resolve9();
+      }
+      setTimeout(() => {
+        try {
+          process.kill(-tracked.child.pid, "SIGKILL");
+        } catch {
+        }
+        resolve9();
+      }, 5e3);
+    });
+    this.stopping.delete(stopKey);
+    this.restartTracker.reset(stopKey);
     try {
-      cb(event);
+      this.removeConnectorPid(mindName, type);
     } catch (err) {
-      console.error("[conversation-events] subscriber threw:", err);
-      set.delete(cb);
-      if (set.size === 0) subscribers2.delete(conversationId);
+      clog.warn(`failed to remove PID file for ${type}/${mindName}`, logger_default.errorData(err));
     }
+    clog.info(`stopped connector ${type} for ${mindName}`);
   }
-}
-
-// src/lib/events/conversations.ts
-async function createConversation(mindName, channel, opts) {
-  const db = await getDb();
-  const id = randomUUID();
-  const type = opts?.type ?? "dm";
-  const name = opts?.name ?? null;
-  await db.transaction(async (tx) => {
-    await tx.insert(conversations).values({
-      id,
-      mind_name: mindName,
-      channel,
+  async stopConnectors(mindName) {
+    const mindMap = this.connectors.get(mindName);
+    if (!mindMap) return;
+    const types = [...mindMap.keys()];
+    await Promise.all(types.map((type) => this.stopConnector(mindName, type)));
+    this.connectors.delete(mindName);
+  }
+  async stopAll() {
+    this.shuttingDown = true;
+    const minds = [...this.connectors.keys()];
+    await Promise.all(minds.map((name) => this.stopConnectors(name)));
+  }
+  getConnectorStatus(mindName) {
+    const mindMap = this.connectors.get(mindName);
+    if (!mindMap) return [];
+    return [...mindMap.entries()].map(([type, tracked]) => ({
       type,
-      name,
-      user_id: opts?.userId ?? null,
-      title: opts?.title ?? null
-    });
-    if (opts?.participantIds && opts.participantIds.length > 0) {
-      await tx.insert(conversationParticipants).values(
-        opts.participantIds.map((uid, i) => ({
-          conversation_id: id,
-          user_id: uid,
-          role: i === 0 ? "owner" : "member"
-        }))
-      );
-    }
-  });
-  fireWebhook({
-    event: "conversation_created",
-    mind: mindName ?? "",
-    data: { id, mindName, channel, type, name, title: opts?.title ?? null }
-  });
-  return {
-    id,
-    mind_name: mindName,
-    channel,
-    type,
-    name,
-    user_id: opts?.userId ?? null,
-    title: opts?.title ?? null,
-    created_at: (/* @__PURE__ */ new Date()).toISOString(),
-    updated_at: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-async function getConversation(id) {
-  const db = await getDb();
-  const row = await db.select().from(conversations).where(eq2(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(
-      eq2(conversationParticipants.conversation_id, conversationId),
-      eq2(conversationParticipants.user_id, userId)
-    )
-  );
-}
-async function getParticipants(conversationId) {
-  const db = await getDb();
-  const rows = await db.select({
-    userId: conversationParticipants.user_id,
-    username: users.username,
-    userType: users.user_type,
-    role: conversationParticipants.role,
-    displayName: users.display_name,
-    description: users.description,
-    avatar: users.avatar
-  }).from(conversationParticipants).innerJoin(users, eq2(conversationParticipants.user_id, users.id)).where(eq2(conversationParticipants.conversation_id, conversationId)).all();
-  return rows;
-}
-async function isParticipant(conversationId, userId) {
-  const db = await getDb();
-  const row = await db.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(
-    and2(
-      eq2(conversationParticipants.conversation_id, conversationId),
-      eq2(conversationParticipants.user_id, userId)
-    )
-  ).get();
-  return row != null;
-}
-async function listConversationsForUser(userId) {
-  const db = await getDb();
-  const participantRows = await db.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(eq2(conversationParticipants.user_id, userId)).all();
-  if (participantRows.length === 0) return [];
-  const convIds = participantRows.map((r) => r.conversation_id);
-  return await db.select().from(conversations).where(inArray(conversations.id, convIds)).orderBy(desc(conversations.updated_at)).all();
-}
-async function isParticipantOrOwner(conversationId, userId) {
-  if (await isParticipant(conversationId, userId)) return true;
-  const db = await getDb();
-  const row = await db.select().from(conversations).where(and2(eq2(conversations.id, conversationId), eq2(conversations.user_id, userId))).get();
-  return row != null;
-}
-async function deleteConversationForUser(id, userId) {
-  if (!await isParticipantOrOwner(id, userId)) return false;
-  await deleteConversation(id);
-  return true;
-}
-async function addMessage(conversationId, role, senderName, content) {
-  const db = await getDb();
-  const serialized = JSON.stringify(content);
-  const [result] = await db.insert(messages).values({ conversation_id: conversationId, role, sender_name: senderName, content: serialized }).returning({ id: messages.id, created_at: messages.created_at });
-  await db.update(conversations).set({ updated_at: sql`datetime('now')` }).where(eq2(conversations.id, conversationId));
-  if (role === "user") {
-    const firstText = content.find((b) => b.type === "text");
-    const title = firstText ? firstText.text.slice(0, 80) : "";
-    if (title) {
-      await db.update(conversations).set({ title }).where(and2(eq2(conversations.id, conversationId), isNull(conversations.title)));
-    }
+      running: !tracked.child.killed
+    }));
   }
-  const msg = {
-    id: result.id,
-    conversation_id: conversationId,
-    role,
-    sender_name: senderName,
-    content,
-    created_at: result.created_at
-  };
-  publish3(conversationId, {
-    type: "message",
-    id: msg.id,
-    role: msg.role,
-    senderName: msg.sender_name,
-    content: msg.content,
-    createdAt: msg.created_at
-  });
-  const conv = await db.select({ mind_name: conversations.mind_name }).from(conversations).where(eq2(conversations.id, conversationId)).get();
-  fireWebhook({
-    event: "message_created",
-    mind: conv?.mind_name ?? "",
-    data: {
-      conversationId,
-      messageId: result.id,
-      role,
-      senderName,
-      content: content.filter((b) => b.type !== "image"),
-      createdAt: result.created_at
-    }
-  });
-  return msg;
-}
-async function getMessages(conversationId) {
-  const db = await getDb();
-  const rows = await db.select().from(messages).where(eq2(messages.conversation_id, conversationId)).orderBy(messages.created_at).all();
-  return rows.map(parseMessageRow);
-}
-async function getMessagesPaginated(conversationId, opts) {
-  const db = await getDb();
-  const limit = Math.min(Math.max(opts?.limit ?? 50, 1), 100);
-  const conditions = [eq2(messages.conversation_id, conversationId)];
-  if (opts?.before != null) {
-    conditions.push(lt(messages.id, opts.before));
+  connectorPidPath(mindName, type) {
+    return resolve3(stateDir(mindName), "connectors", `${type}.pid`);
   }
-  const rows = await db.select().from(messages).where(and2(...conditions)).orderBy(desc(messages.id)).limit(limit + 1).all();
-  const hasMore = rows.length > limit;
-  const page = rows.slice(0, limit).reverse();
-  return {
-    messages: page.map(parseMessageRow),
-    hasMore
-  };
-}
-function parseMessageRow(row) {
-  let content;
-  try {
-    const parsed = JSON.parse(row.content);
-    content = Array.isArray(parsed) ? parsed : [{ type: "text", text: row.content }];
-  } catch {
-    content = [{ type: "text", text: row.content }];
+  saveConnectorPid(mindName, type, pid) {
+    const pidPath = this.connectorPidPath(mindName, type);
+    mkdirSync(dirname(pidPath), { recursive: true });
+    writeFileSync(pidPath, String(pid));
   }
-  return { ...row, role: row.role, content };
-}
-async function listConversationsWithParticipants(userId) {
-  const convs = await listConversationsForUser(userId);
-  if (convs.length === 0) return [];
-  const db = await getDb();
-  const convIds = convs.map((c) => c.id);
-  const rows = await db.select({
-    conversationId: conversationParticipants.conversation_id,
-    userId: users.id,
-    username: users.username,
-    userType: users.user_type,
-    role: conversationParticipants.role,
-    displayName: users.display_name,
-    description: users.description,
-    avatar: users.avatar
-  }).from(conversationParticipants).innerJoin(users, eq2(conversationParticipants.user_id, users.id)).where(inArray(conversationParticipants.conversation_id, convIds));
-  const byConv = /* @__PURE__ */ new Map();
-  for (const r of rows) {
-    let arr = byConv.get(r.conversationId);
-    if (!arr) {
-      arr = [];
-      byConv.set(r.conversationId, arr);
-    }
-    arr.push({
-      userId: r.userId,
-      username: r.username,
-      userType: r.userType,
-      role: r.role,
-      displayName: r.displayName,
-      description: r.description,
-      avatar: r.avatar
-    });
+  removeConnectorPid(mindName, type) {
+    try {
+      unlinkSync(this.connectorPidPath(mindName, type));
+    } catch {
+    }
   }
-  const lastMsgIds = await db.select({
-    conversationId: messages.conversation_id,
-    maxId: sql`MAX(${messages.id})`
-  }).from(messages).where(inArray(messages.conversation_id, convIds)).groupBy(messages.conversation_id);
-  const byLastMsg = /* @__PURE__ */ new Map();
-  if (lastMsgIds.length > 0) {
-    const msgRows = await db.select().from(messages).where(
-      inArray(
-        messages.id,
-        lastMsgIds.map((r) => r.maxId)
-      )
-    );
-    for (const m of msgRows) {
-      let text = "";
-      try {
-        const parsed = JSON.parse(m.content);
-        const blocks = Array.isArray(parsed) ? parsed : [];
-        const textBlock = blocks.find((b) => b.type === "text");
-        if (textBlock && "text" in textBlock) text = textBlock.text;
-      } catch {
-        text = m.content;
+  killOrphanConnector(mindName, type) {
+    const pidPath = this.connectorPidPath(mindName, type);
+    if (!existsSync3(pidPath)) return;
+    try {
+      const pid = parseInt(readFileSync2(pidPath, "utf-8").trim(), 10);
+      if (pid > 0) {
+        try {
+          process.kill(-pid, "SIGTERM");
+        } catch {
+          process.kill(pid, "SIGTERM");
+        }
+        clog.warn(`killed orphan connector ${type} (pid ${pid})`);
       }
-      byLastMsg.set(m.conversation_id, {
-        role: m.role,
-        senderName: m.sender_name,
-        text,
-        createdAt: m.created_at
-      });
+    } catch {
     }
-  }
-  return convs.map((c) => ({
-    ...c,
-    participants: byConv.get(c.id) ?? [],
-    lastMessage: byLastMsg.get(c.id)
-  }));
-}
-async function findDMConversation(mindName, participantIds) {
-  const db = await getDb();
-  const mindConvs = await db.select({ id: conversations.id }).from(conversations).where(and2(eq2(conversations.mind_name, mindName), eq2(conversations.type, "dm"))).all();
-  for (const conv of mindConvs) {
-    const rows = await db.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(eq2(conversationParticipants.conversation_id, conv.id)).all();
-    if (rows.length !== 2) continue;
-    const ids = new Set(rows.map((r) => r.user_id));
-    if (ids.has(participantIds[0]) && ids.has(participantIds[1])) {
-      return conv.id;
+    try {
+      unlinkSync(pidPath);
+    } catch {
     }
   }
-  return null;
-}
-async function deleteConversation(id) {
-  const db = await getDb();
-  await db.delete(conversations).where(eq2(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(eq2(conversations.name, name), eq2(conversations.type, "channel"))).get();
-  return row ?? null;
-}
-async function listChannels() {
-  const db = await getDb();
-  return await db.select().from(conversations).where(eq2(conversations.type, "channel")).orderBy(conversations.name).all();
-}
-async function joinChannel(conversationId, userId) {
-  if (await isParticipant(conversationId, userId)) return;
-  await addParticipant(conversationId, userId);
+  resolveBuiltinConnector(type) {
+    return searchUpwards("connectors", `${type}.js`);
+  }
+  resolveVoluteTsx() {
+    return searchUpwards("node_modules", ".bin", "tsx") ?? "tsx";
+  }
+};
+var instance = null;
+function initConnectorManager() {
+  if (instance) throw new Error("ConnectorManager already initialized");
+  instance = new ConnectorManager();
+  return instance;
 }
-async function leaveChannel(conversationId, userId) {
-  await removeParticipant(conversationId, userId);
+function getConnectorManager() {
+  if (!instance)
+    throw new Error("ConnectorManager not initialized \u2014 call initConnectorManager() first");
+  return instance;
 }
-async function getUnreadCounts(userId, conversationIds) {
-  if (conversationIds.length === 0) return {};
-  const db = await getDb();
-  const rows = await db.select({
-    conversationId: messages.conversation_id,
-    count: sql`COUNT(*)`
-  }).from(messages).leftJoin(
-    conversationReads,
-    and2(
-      eq2(conversationReads.conversation_id, messages.conversation_id),
-      eq2(conversationReads.user_id, userId)
-    )
-  ).where(
-    and2(
-      inArray(messages.conversation_id, conversationIds),
-      sql`${messages.id} > COALESCE(${conversationReads.last_read_message_id}, 0)`
-    )
-  ).groupBy(messages.conversation_id);
-  const result = {};
-  for (const row of rows) {
-    result[row.conversationId] = row.count;
+
+// src/lib/events/mind-events.ts
+var subscribers2 = /* @__PURE__ */ new Map();
+function subscribe3(mind, callback) {
+  let set = subscribers2.get(mind);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    subscribers2.set(mind, set);
   }
-  return result;
+  set.add(callback);
+  return () => {
+    set.delete(callback);
+    if (set.size === 0) subscribers2.delete(mind);
+  };
 }
-async function markConversationRead(userId, conversationId) {
-  const db = await getDb();
-  const maxRow = await db.select({ maxId: sql`MAX(${messages.id})` }).from(messages).where(eq2(messages.conversation_id, conversationId)).get();
-  const maxId = maxRow?.maxId ?? 0;
-  if (maxId === 0) return;
-  await db.insert(conversationReads).values({ user_id: userId, conversation_id: conversationId, last_read_message_id: maxId }).onConflictDoUpdate({
-    target: [conversationReads.user_id, conversationReads.conversation_id],
-    set: { last_read_message_id: maxId }
-  });
+function publish3(mind, event) {
+  const set = subscribers2.get(mind);
+  if (!set) return;
+  for (const cb of set) {
+    try {
+      cb(event);
+    } catch (err) {
+      console.error("[mind-events] subscriber threw:", err);
+      set.delete(cb);
+      if (set.size === 0) subscribers2.delete(mind);
+    }
+  }
 }
 
+// src/lib/delivery/delivery-manager.ts
+import { readFile, realpath } from "fs/promises";
+import { extname, resolve as resolve5 } from "path";
+import { and as and3, eq as eq3, sql as sql2 } from "drizzle-orm";
+
 // src/lib/typing.ts
 var DEFAULT_TTL_MS = 1e4;
 var SWEEP_INTERVAL_MS = 5e3;
@@ -1281,7 +1335,7 @@ function publishTypingForChannels(channels, map) {
   for (const channel of channels) {
     if (channel.startsWith(VOLUTE_PREFIX)) {
       const conversationId = channel.slice(VOLUTE_PREFIX.length);
-      publish3(conversationId, { type: "typing", senders: map.get(channel) });
+      publish2(conversationId, { type: "typing", senders: map.get(channel) });
     }
   }
 }
@@ -1990,8 +2044,26 @@ var DeliveryManager = class {
         if (p.userType === "mind") {
           const dir = mindDir(p.username);
           const config = readVoluteConfig(dir);
-          if (!config?.avatar) continue;
-          filePath = resolve5(dir, "home", config.avatar);
+          if (!config?.profile?.avatar) continue;
+          filePath = resolve5(dir, "home", config.profile.avatar);
+          const homeDir = resolve5(dir, "home");
+          if (!filePath.startsWith(`${homeDir}/`)) {
+            dlog2.warn(`avatar path for ${p.username} escapes home directory, skipping`);
+            continue;
+          }
+          try {
+            const realHome = await realpath(homeDir);
+            const realAvatar = await realpath(filePath);
+            if (!realAvatar.startsWith(`${realHome}/`)) {
+              dlog2.warn(
+                `avatar symlink for ${p.username} resolves outside home directory, skipping`
+              );
+              continue;
+            }
+          } catch (err) {
+            if (err.code === "ENOENT") continue;
+            throw err;
+          }
         } else {
           filePath = resolve5(voluteHome(), "avatars", p.avatar);
         }
@@ -2082,7 +2154,7 @@ async function recordInbound(mind, channel, sender, content) {
   } catch (err) {
     dlog3.warn(`failed to persist inbound for ${mind}`, logger_default.errorData(err));
   }
-  publish2(mind, {
+  publish3(mind, {
     mind,
     type: "inbound",
     channel,
@@ -2433,6 +2505,18 @@ var Scheduler = class {
     return false;
   }
   async fire(mindName, schedule) {
+    const sleepManager = getSleepManagerIfReady();
+    const sleepState = sleepManager?.getState(mindName);
+    if (sleepState?.sleeping) {
+      if (schedule.skipWhenSleeping) {
+        slog2.info(`skipped "${schedule.id}" for ${mindName} (sleeping)`);
+        return;
+      }
+      if (sleepState.wokenByTrigger) {
+        slog2.info(`skipped "${schedule.id}" for ${mindName} (trigger-woken)`);
+        return;
+      }
+    }
     try {
       let text;
       if (schedule.script) {
@@ -2458,7 +2542,7 @@ ${stderr}` : ""}`;
       }
       await this.deliver(mindName, {
         content: [{ type: "text", text }],
-        channel: "system:scheduler",
+        channel: schedule.channel ?? "system:scheduler",
         sender: schedule.id
       });
       slog2.info(`fired "${schedule.id}" for ${mindName}`);
@@ -2702,14 +2786,13 @@ async function startMindFull(name) {
   );
   const config = readVoluteConfig(dir);
   if (config) {
-    syncMindProfile(baseName, {
-      displayName: config.displayName,
-      description: config.description,
-      avatar: config.avatar
-    }).catch(
+    syncMindProfile(baseName, config.profile ?? {}).catch(
       (err) => logger_default.error(`failed to sync profile for ${baseName}`, logger_default.errorData(err))
     );
   }
+  joinSystemChannelForMind(baseName).catch(
+    (err) => logger_default.error(`failed to join #system for ${baseName}`, logger_default.errorData(err))
+  );
   if (config?.tokenBudget) {
     getTokenBudget().setBudget(
       baseName,
@@ -2762,7 +2845,8 @@ function defaultState() {
     scheduledWakeAt: null,
     wokenByTrigger: false,
     voluntaryWakeAt: null,
-    queuedMessageCount: 0
+    queuedMessageCount: 0,
+    triggerWakeHistory: []
   };
 }
 function formatCurrentDate() {
@@ -2809,6 +2893,7 @@ var SleepManager = class {
       if (existsSync5(this.statePath)) {
         const data = JSON.parse(readFileSync5(this.statePath, "utf-8"));
         for (const [name, state] of Object.entries(data)) {
+          state.triggerWakeHistory ??= [];
           this.states.set(name, state);
         }
       }
@@ -2838,6 +2923,16 @@ var SleepManager = class {
   getState(name) {
     return this.states.get(name) ?? defaultState();
   }
+  /**
+   * Convert a trigger-wake into a full wake. The mind is already running;
+   * this just clears the sleep state so onActivityEvent won't return it to sleep.
+   */
+  convertTriggerToFullWake(name) {
+    const state = this.states.get(name);
+    if (!state?.sleeping || !state.wokenByTrigger) return;
+    this.markAwake(name);
+    slog3.info(`${name} trigger-wake converted to full wake`);
+  }
   getSleepConfig(name) {
     const dir = mindDir(name);
     const config = readVoluteConfig(dir);
@@ -2906,15 +3001,6 @@ var SleepManager = class {
     if (this.transitioning.has(name)) return;
     this.transitioning.add(name);
     try {
-      const sleepingSince = state.sleepingSince ? new Date(state.sleepingSince) : /* @__PURE__ */ new Date();
-      const now = /* @__PURE__ */ new Date();
-      const duration = formatDuration(sleepingSince, now);
-      const currentDate = formatCurrentDate();
-      const sleepTime = sleepingSince.toLocaleTimeString("en-US", {
-        hour: "numeric",
-        minute: "2-digit"
-      });
-      const queuedSummary = await this.buildQueuedSummary(name);
       try {
         await wakeMind(name);
       } catch (err) {
@@ -2923,46 +3009,59 @@ var SleepManager = class {
       }
       const entry = findMind(name);
       if (!entry) return;
-      let summaryText;
       if (opts?.trigger) {
         state.wokenByTrigger = true;
-        summaryText = await getPrompt("wake_trigger_summary", {
-          currentDate,
-          triggerChannel: opts.trigger.channel,
-          sleepTime,
-          duration,
-          queuedSummary
+        state.triggerWakeHistory.push({
+          channel: opts.trigger.channel,
+          at: (/* @__PURE__ */ new Date()).toISOString()
         });
+        this.saveState();
       } else {
-        summaryText = await getPrompt("wake_summary", {
+        const sleepingSince = state.sleepingSince ? new Date(state.sleepingSince) : /* @__PURE__ */ new Date();
+        const now = /* @__PURE__ */ new Date();
+        const duration = formatDuration(sleepingSince, now);
+        const currentDate = formatCurrentDate();
+        const sleepTime = sleepingSince.toLocaleTimeString("en-US", {
+          hour: "numeric",
+          minute: "2-digit"
+        });
+        const triggerWakeSummary = this.buildTriggerWakeSummary(state);
+        const wakeContext = await this.runWakeContextScript(
+          name,
+          state.sleepingSince ?? sleepingSince.toISOString(),
+          duration
+        );
+        const queuedSummary = await this.buildQueuedSummary(name);
+        const sleepActivity = [triggerWakeSummary, wakeContext, queuedSummary].filter(Boolean).join("\n\n");
+        const summaryText = await getPrompt("wake_summary", {
           currentDate,
           sleepTime,
           duration,
-          queuedSummary
-        });
-      }
-      try {
-        const db = await getDb();
-        await db.insert(mindHistory).values({
-          mind: name,
-          type: "inbound",
-          channel: "system:sleep",
-          content: summaryText
-        });
-      } catch (err) {
-        slog3.error(`failed to persist wake summary for ${name}`, logger_default.errorData(err));
-      }
-      try {
-        await fetch(`http://127.0.0.1:${entry.port}/message`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            content: [{ type: "text", text: summaryText }],
-            channel: "system:sleep"
-          })
+          sleepActivity
         });
-      } catch (err) {
-        slog3.warn(`failed to deliver wake summary to ${name}`, logger_default.errorData(err));
+        try {
+          const db = await getDb();
+          await db.insert(mindHistory).values({
+            mind: name,
+            type: "inbound",
+            channel: "system:sleep",
+            content: summaryText
+          });
+        } catch (err) {
+          slog3.error(`failed to persist wake summary for ${name}`, logger_default.errorData(err));
+        }
+        try {
+          await fetch(`http://127.0.0.1:${entry.port}/message`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              content: [{ type: "text", text: summaryText }],
+              channel: "system:sleep"
+            })
+          });
+        } catch (err) {
+          slog3.warn(`failed to deliver wake summary to ${name}`, logger_default.errorData(err));
+        }
       }
       const flushed = await this.flushQueuedMessages(name);
       if (flushed > 0) {
@@ -3028,7 +3127,7 @@ var SleepManager = class {
       const db = await getDb();
       const rows = await db.select().from(deliveryQueue).where(and4(eq4(deliveryQueue.mind, name), eq4(deliveryQueue.status, "sleep-queued"))).all();
       if (rows.length === 0) return 0;
-      const { deliverMessage: deliverMessage2 } = await import("./message-delivery-S7BCNV6Y.js");
+      const { deliverMessage: deliverMessage2 } = await import("./message-delivery-MS5JYPZX.js");
       const delivered = [];
       for (const row of rows) {
         try {
@@ -3039,7 +3138,7 @@ var SleepManager = class {
         }
       }
       if (delivered.length > 0) {
-        await db.delete(deliveryQueue).where(inArray2(deliveryQueue.id, delivered));
+        await db.delete(deliveryQueue).where(inArray3(deliveryQueue.id, delivered));
       }
       const state = this.states.get(name);
       if (state) {
@@ -3060,7 +3159,8 @@ var SleepManager = class {
       scheduledWakeAt: this.getNextWakeTime(sleepConfig),
       wokenByTrigger: false,
       voluntaryWakeAt: opts?.voluntaryWakeAt ?? null,
-      queuedMessageCount: this.states.get(name)?.queuedMessageCount ?? 0
+      queuedMessageCount: this.states.get(name)?.queuedMessageCount ?? 0,
+      triggerWakeHistory: []
     };
     this.states.set(name, state);
     this.saveState();
@@ -3177,18 +3277,70 @@ var SleepManager = class {
       }
     }
   }
+  async runWakeContextScript(name, sleepingSince, duration) {
+    const scriptPath = resolve8(mindDir(name), "home", ".config", "hooks", "wake-context.sh");
+    if (!existsSync5(scriptPath)) return "";
+    const input = JSON.stringify({
+      sleepingSince,
+      duration,
+      wakeTime: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    try {
+      const result = await new Promise((resolvePromise, reject) => {
+        const child = spawnChild("bash", [scriptPath], {
+          cwd: mindDir(name),
+          timeout: 5e3,
+          env: { ...process.env, VOLUTE_MIND: name },
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (data) => {
+          stdout += data.toString();
+        });
+        child.stderr.on("data", (data) => {
+          stderr += data.toString();
+        });
+        child.on("close", (code) => {
+          if (code === 0) resolvePromise(stdout);
+          else
+            reject(
+              new Error(
+                `wake-context script exited with code ${code}${stderr ? `: ${stderr.trim()}` : ""}`
+              )
+            );
+        });
+        child.on("error", reject);
+        child.stdin.end(input);
+      });
+      return result.trim();
+    } catch (err) {
+      slog3.warn(`wake-context script failed for ${name}`, logger_default.errorData(err));
+      return "";
+    }
+  }
+  buildTriggerWakeSummary(state) {
+    const history = state.triggerWakeHistory;
+    if (!history || history.length === 0) return "";
+    const channels = [...new Set(history.map((h) => h.channel))];
+    const times = history.length === 1 ? "once" : `${history.length} times`;
+    return `You were briefly woken ${times} during sleep to handle messages on ${channels.join(", ")} (sessions were archived after each).`;
+  }
   async buildQueuedSummary(name) {
     try {
       const db = await getDb();
-      const rows = await db.select({ channel: deliveryQueue.channel }).from(deliveryQueue).where(and4(eq4(deliveryQueue.mind, name), eq4(deliveryQueue.status, "sleep-queued"))).all();
+      const rows = await db.select({ channel: deliveryQueue.channel, sender: deliveryQueue.sender }).from(deliveryQueue).where(and4(eq4(deliveryQueue.mind, name), eq4(deliveryQueue.status, "sleep-queued"))).all();
       if (rows.length === 0) return "No messages arrived while you slept.";
       const channelCounts = /* @__PURE__ */ new Map();
+      const senders = /* @__PURE__ */ new Set();
       for (const row of rows) {
         const ch = row.channel ?? "unknown";
         channelCounts.set(ch, (channelCounts.get(ch) ?? 0) + 1);
+        if (row.sender) senders.add(row.sender);
       }
       const parts = [...channelCounts.entries()].map(([ch, count2]) => `${count2} on ${ch}`);
-      return `${rows.length} message${rows.length === 1 ? "" : "s"} arrived while you slept (${parts.join(", ")}). They'll be delivered to your normal channels now.`;
+      const senderNote = senders.size > 0 ? ` from ${[...senders].join(", ")}` : "";
+      return `${rows.length} message${rows.length === 1 ? "" : "s"} arrived while you slept${senderNote} (${parts.join(", ")}). They'll be delivered to your normal channels now.`;
     } catch (err) {
       slog3.error(`failed to build queued summary for ${name}`, logger_default.errorData(err));
       return "Unable to check for queued messages \u2014 there may be messages waiting.";
@@ -3291,8 +3443,6 @@ function getSleepManagerIfReady() {
 }
 
 export {
-  initConnectorManager,
-  getConnectorManager,
   createUser,
   verifyUser,
   getUser,
@@ -3308,28 +3458,18 @@ export {
   setUserRole,
   deleteUser,
   updateUserProfile,
+  migrateMindRoles,
+  initConnectorManager,
+  getConnectorManager,
   stopAllWatchers,
   getCachedSites,
   getCachedRecentPages,
-  initScheduler,
-  getScheduler,
-  initTokenBudget,
-  getTokenBudget,
-  startMindFull,
-  stopMindFull,
-  matchesGlob,
-  SleepManager,
-  initSleepManager,
-  getSleepManager,
-  getSleepManagerIfReady,
-  subscribe2 as subscribe,
-  publish2 as publish,
   getWebhookUrl,
   getAuthHeaders,
   fireWebhook,
   initWebhook,
-  subscribe3 as subscribe2,
-  publish3 as publish2,
+  subscribe2 as subscribe,
+  publish2 as publish,
   createConversation,
   getConversation,
   getParticipants,
@@ -3349,6 +3489,22 @@ export {
   leaveChannel,
   getUnreadCounts,
   markConversationRead,
+  ensureSystemChannel,
+  joinSystemChannel,
+  announceToSystem,
+  initScheduler,
+  getScheduler,
+  initTokenBudget,
+  getTokenBudget,
+  startMindFull,
+  stopMindFull,
+  matchesGlob,
+  SleepManager,
+  initSleepManager,
+  getSleepManager,
+  getSleepManagerIfReady,
+  subscribe3 as subscribe2,
+  publish3 as publish2,
   getTypingMap,
   publishTypingForChannels,
   extractTextContent,