volute 0.23.0 → 0.25.0

package/dist/{chunk-ISWZ6QUK.js → chunk-PMX4EIJK.js}

@@ -4,11 +4,12 @@ import {
 } from "./chunk-HFCBO2GL.js";
 import {
   markIdle
-} from "./chunk-HGCDWKSP.js";
+} from "./chunk-E7GOKNOT.js";
 import {
+  broadcast,
   publish,
   subscribe
-} from "./chunk-A4S7H6G6.js";
+} from "./chunk-BFK6SOEJ.js";
 import {
   RestartTracker,
   RotatingLog,
@@ -17,18 +18,23 @@ import {
   getPrompt,
   loadJsonMap,
   saveJsonMap
-} from "./chunk-M5CNKH4J.js";
+} from "./chunk-SHSWYG2J.js";
 import {
   readVoluteConfig
-} from "./chunk-XLC342FO.js";
+} from "./chunk-SIAG3QMM.js";
 import {
   loadMergedEnv
 } from "./chunk-PHU4DEAJ.js";
 import {
+  conversationParticipants,
+  conversationReads,
+  conversations,
   deliveryQueue,
   getDb,
-  mindHistory
-} from "./chunk-SGPEZ32F.js";
+  messages,
+  mindHistory,
+  users
+} from "./chunk-33XAVCS4.js";
 import {
   logger_default
 } from "./chunk-YUIHSKR6.js";
@@ -61,10 +67,136 @@ import {
   renameSync,
   writeFileSync as writeFileSync3
 } from "fs";
-import { resolve as resolve7 } from "path";
+import { resolve as resolve8 } from "path";
 import { promisify } from "util";
 import { CronExpressionParser as CronExpressionParser2 } from "cron-parser";
-import { and as and2, eq as eq2, inArray } from "drizzle-orm";
+import { and as and4, eq as eq4, inArray as inArray2 } from "drizzle-orm";
+
+// src/lib/auth.ts
+import { compareSync, hashSync } from "bcryptjs";
+import { and, count, eq } from "drizzle-orm";
+var userSelectFields = {
+  id: users.id,
+  username: users.username,
+  role: users.role,
+  user_type: users.user_type,
+  display_name: users.display_name,
+  description: users.description,
+  avatar: users.avatar,
+  created_at: users.created_at
+};
+async function createUser(username, password) {
+  const db = await getDb();
+  const hash = hashSync(password, 10);
+  const [{ value }] = await db.select({ value: count() }).from(users).where(eq(users.user_type, "brain"));
+  const role = value === 0 ? "admin" : "pending";
+  const [result] = await db.insert(users).values({ username, password_hash: hash, role }).returning(userSelectFields);
+  return result;
+}
+async function verifyUser(username, password) {
+  const db = await getDb();
+  const row = await db.select().from(users).where(eq(users.username, username)).get();
+  if (!row) return null;
+  if (row.user_type === "mind") return null;
+  if (!compareSync(password, row.password_hash)) return null;
+  const { password_hash: _, ...user } = row;
+  return user;
+}
+async function getUser(id) {
+  const db = await getDb();
+  const row = await db.select(userSelectFields).from(users).where(eq(users.id, id)).get();
+  return row ?? null;
+}
+async function getUserByUsername(username) {
+  const db = await getDb();
+  const row = await db.select(userSelectFields).from(users).where(eq(users.username, username)).get();
+  return row ?? null;
+}
+async function listUsers() {
+  const db = await getDb();
+  return db.select(userSelectFields).from(users).orderBy(users.created_at).all();
+}
+async function listPendingUsers() {
+  const db = await getDb();
+  return db.select(userSelectFields).from(users).where(eq(users.role, "pending")).orderBy(users.created_at).all();
+}
+async function listUsersByType(userType) {
+  const db = await getDb();
+  return db.select(userSelectFields).from(users).where(eq(users.user_type, userType)).orderBy(users.created_at).all();
+}
+async function getOrCreateMindUser(mindName) {
+  const db = await getDb();
+  const existing = await db.select(userSelectFields).from(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind"))).get();
+  if (existing) return existing;
+  try {
+    const [result] = await db.insert(users).values({
+      username: mindName,
+      password_hash: "!mind",
+      role: "mind",
+      user_type: "mind"
+    }).returning(userSelectFields);
+    return result;
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
+      const retried = await db.select(userSelectFields).from(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind"))).get();
+      if (retried) return retried;
+    }
+    throw err;
+  }
+}
+async function deleteMindUser(mindName) {
+  const db = await getDb();
+  await db.delete(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind")));
+}
+async function changePassword(userId, currentPassword, newPassword) {
+  const db = await getDb();
+  const row = await db.select().from(users).where(eq(users.id, userId)).get();
+  if (!row) return false;
+  if (!compareSync(currentPassword, row.password_hash)) return false;
+  const hash = hashSync(newPassword, 10);
+  await db.update(users).set({ password_hash: hash }).where(eq(users.id, userId));
+  return true;
+}
+async function approveUser(id) {
+  const db = await getDb();
+  await db.update(users).set({ role: "user" }).where(and(eq(users.id, id), eq(users.role, "pending")));
+}
+async function countAdmins() {
+  const db = await getDb();
+  const [{ value }] = await db.select({ value: count() }).from(users).where(eq(users.role, "admin"));
+  return value;
+}
+async function setUserRole(id, role) {
+  const db = await getDb();
+  const target = await db.select({ id: users.id }).from(users).where(eq(users.id, id)).get();
+  if (!target) throw new Error("User not found");
+  await db.update(users).set({ role }).where(eq(users.id, id));
+}
+async function deleteUser(id) {
+  const db = await getDb();
+  const target = await db.select({ id: users.id }).from(users).where(and(eq(users.id, id), eq(users.user_type, "brain"))).get();
+  if (!target) throw new Error("User not found");
+  await db.delete(users).where(and(eq(users.id, id), eq(users.user_type, "brain")));
+}
+async function updateUserProfile(userId, profile) {
+  const db = await getDb();
+  const target = await db.select({ id: users.id }).from(users).where(eq(users.id, userId)).get();
+  if (!target) throw new Error("User not found");
+  await db.update(users).set(profile).where(eq(users.id, userId));
+}
+async function syncMindProfile(mindName, config) {
+  const user = await getOrCreateMindUser(mindName);
+  const newProfile = {
+    display_name: config.displayName ?? null,
+    description: config.description ?? null,
+    avatar: config.avatar ?? null
+  };
+  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` });
+}
 
 // src/lib/pages-watcher.ts
 import { existsSync, readdirSync, statSync, watch } from "fs";
@@ -104,16 +236,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();
@@ -210,7 +342,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) {
@@ -223,7 +355,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 {
@@ -521,19 +653,19 @@ var ConnectorManager = class {
     const stopKey = `${mindName}:${type}`;
     this.stopping.add(stopKey);
     mindMap.delete(type);
-    await new Promise((resolve8) => {
-      tracked.child.on("exit", () => resolve8());
+    await new Promise((resolve9) => {
+      tracked.child.on("exit", () => resolve9());
       try {
         process.kill(-tracked.child.pid, "SIGTERM");
       } catch {
-        resolve8();
+        resolve9();
       }
       setTimeout(() => {
         try {
           process.kill(-tracked.child.pid, "SIGKILL");
         } catch {
         }
-        resolve8();
+        resolve9();
       }, 5e3);
     });
     this.stopping.delete(stopKey);
@@ -647,7 +779,75 @@ function publish2(mind, event) {
 }
 
 // src/lib/delivery/delivery-manager.ts
-import { and, eq, sql } from "drizzle-orm";
+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/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();
@@ -677,6 +877,330 @@ function publish3(conversationId, event) {
   }
 }
 
+// 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"
+        }))
+      );
+    }
+  });
+  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)));
+    }
+  }
+  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));
+  }
+  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(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
+    });
+  }
+  const lastMsgIds = await db.select({
+    conversationId: messages.conversation_id,
+    maxId: sql`MAX(${messages.id})`
+  }).from(messages).where(inArray(messages.conversation_id, convIds)).groupBy(messages.conversation_id);
+  const byLastMsg = /* @__PURE__ */ new Map();
+  if (lastMsgIds.length > 0) {
+    const msgRows = await db.select().from(messages).where(
+      inArray(
+        messages.id,
+        lastMsgIds.map((r) => r.maxId)
+      )
+    );
+    for (const m of msgRows) {
+      let text = "";
+      try {
+        const parsed = JSON.parse(m.content);
+        const blocks = Array.isArray(parsed) ? parsed : [];
+        const textBlock = blocks.find((b) => b.type === "text");
+        if (textBlock && "text" in textBlock) text = textBlock.text;
+      } catch {
+        text = m.content;
+      }
+      byLastMsg.set(m.conversation_id, {
+        role: m.role,
+        senderName: m.sender_name,
+        text,
+        createdAt: m.created_at
+      });
+    }
+  }
+  return convs.map((c) => ({
+    ...c,
+    participants: byConv.get(c.id) ?? [],
+    lastMessage: byLastMsg.get(c.id)
+  }));
+}
+async function findDMConversation(mindName, participantIds) {
+  const db = await getDb();
+  const mindConvs = await db.select({ id: conversations.id }).from(conversations).where(and2(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(
+      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;
+  }
+  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/typing.ts
 var DEFAULT_TTL_MS = 1e4;
 var SWEEP_INTERVAL_MS = 5e3;
@@ -826,7 +1350,7 @@ function globMatch(pattern, value) {
   return regex.test(value);
 }
 var GLOB_MATCH_KEYS = /* @__PURE__ */ new Set(["channel", "sender"]);
-var NON_MATCH_KEYS = /* @__PURE__ */ new Set(["session", "destination", "path", "mode"]);
+var NON_MATCH_KEYS = /* @__PURE__ */ new Set(["session", "destination", "path", "mode", "batch"]);
 function ruleMatches(rule, meta) {
   for (const [key, pattern] of Object.entries(rule)) {
     if (NON_MATCH_KEYS.has(key)) continue;
@@ -871,7 +1395,8 @@ function resolveRoute(config, meta) {
         destination: "mind",
         session: sanitizeSessionName(expandTemplate(rule.session ?? fallback, meta)),
         matched: true,
-        mode: rule.mode
+        mode: rule.mode,
+        rule
       };
     }
   }
@@ -883,12 +1408,27 @@ function normalizeBatchConfig(batch) {
   if (typeof batch === "number") return { maxWait: batch * 60 };
   return batch;
 }
-function resolveDeliveryMode(config, sessionName) {
+function resolveDeliveryMode(config, sessionName, rule) {
+  const ruleBatch = rule?.batch;
   const defaults = {
     delivery: { mode: "immediate" },
     interrupt: true
   };
-  if (!config.sessions) return defaults;
+  if (!config.sessions) {
+    if (ruleBatch != null) {
+      const batch = normalizeBatchConfig(ruleBatch);
+      return {
+        delivery: {
+          mode: "batch",
+          debounce: batch.debounce ?? DEFAULT_BATCH_DEBOUNCE,
+          maxWait: batch.maxWait ?? DEFAULT_BATCH_MAX_WAIT,
+          triggers: batch.triggers
+        },
+        interrupt: true
+      };
+    }
+    return defaults;
+  }
   for (const [pattern, sessionConfig] of Object.entries(config.sessions)) {
     if (globMatch(pattern, sessionName)) {
       let delivery;
@@ -932,6 +1472,18 @@ function resolveDeliveryMode(config, sessionName) {
       };
     }
   }
+  if (ruleBatch != null) {
+    const batch = normalizeBatchConfig(ruleBatch);
+    return {
+      delivery: {
+        mode: "batch",
+        debounce: batch.debounce ?? DEFAULT_BATCH_DEBOUNCE,
+        maxWait: batch.maxWait ?? DEFAULT_BATCH_MAX_WAIT,
+        triggers: batch.triggers
+      },
+      interrupt: true
+    };
+  }
   return defaults;
 }
 
@@ -981,7 +1533,7 @@ var DeliveryManager = class {
     if (sessionName === "$new") {
       sessionName = `new-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     }
-    const sessionConfig = resolveDeliveryMode(config, sessionName);
+    const sessionConfig = resolveDeliveryMode(config, sessionName, route.rule);
     if (sessionConfig.delivery.mode === "batch") {
       dlog2.debug(`enqueueing batch message for ${mindName}/${sessionName}`);
       this.enqueueBatch(mindName, sessionName, payload, sessionConfig);
@@ -1013,7 +1565,7 @@ var DeliveryManager = class {
   async restoreFromDb() {
     try {
       const db = await getDb();
-      const rows = await db.select().from(deliveryQueue).where(eq(deliveryQueue.status, "pending"));
+      const rows = await db.select().from(deliveryQueue).where(eq3(deliveryQueue.status, "pending"));
       for (const row of rows) {
         let payload;
         try {
@@ -1031,7 +1583,7 @@ var DeliveryManager = class {
           this.addToBatchBuffer(row.mind, row.session, payload, sessionConfig);
         } else {
           try {
-            await db.delete(deliveryQueue).where(eq(deliveryQueue.id, row.id));
+            await db.delete(deliveryQueue).where(eq3(deliveryQueue.id, row.id));
           } catch (err) {
             dlog2.warn(`failed to delete queue row ${row.id} for ${row.mind}`, logger_default.errorData(err));
           }
@@ -1052,7 +1604,7 @@ var DeliveryManager = class {
    */
   async getPending(mindName) {
     const db = await getDb();
-    const rows = await db.select().from(deliveryQueue).where(and(eq(deliveryQueue.mind, mindName), eq(deliveryQueue.status, "gated")));
+    const rows = await db.select().from(deliveryQueue).where(and3(eq3(deliveryQueue.mind, mindName), eq3(deliveryQueue.status, "gated")));
     const byChannel = /* @__PURE__ */ new Map();
     for (const row of rows) {
       const ch = row.channel ?? "unknown";
@@ -1145,8 +1697,9 @@ var DeliveryManager = class {
     if (payload.conversationId) {
       typingMap.set(`volute:${payload.conversationId}`, baseName, { persistent: true });
     }
+    const enrichedPayload = await this.enrichWithProfiles(baseName, session, payload);
     const body = JSON.stringify({
-      ...payload,
+      ...enrichedPayload,
       session,
       interrupt: sessionConfig.interrupt,
       instructions: sessionConfig.instructions
@@ -1163,22 +1716,30 @@ var DeliveryManager = class {
       publishTypingForChannels(typingMap.deleteSender(baseName), typingMap);
     }
   }
-  async deliverBatchToMind(mindName, session, messages, sessionConfig, interruptOverride) {
+  async deliverBatchToMind(mindName, session, messages2, sessionConfig, interruptOverride) {
     const resolved = this.resolvePort(mindName);
     if (!resolved) {
       dlog2.warn(`cannot deliver batch to ${mindName}: mind not found`);
       return;
     }
     const { baseName, port } = resolved;
+    const enrichedMessages = await Promise.all(
+      messages2.map(async (msg, i) => {
+        const isFirst = messages2.findIndex((m) => m.channel === msg.channel) === i;
+        if (!isFirst) return msg;
+        const enrichedPayload = await this.enrichWithProfiles(baseName, session, msg.payload);
+        return { ...msg, payload: enrichedPayload };
+      })
+    );
     const channels = {};
-    for (const msg of messages) {
+    for (const msg of enrichedMessages) {
       const ch = msg.channel ?? "unknown";
       if (!channels[ch]) channels[ch] = [];
       channels[ch].push(msg.payload);
     }
     const senders = /* @__PURE__ */ new Set();
     const channelSet = /* @__PURE__ */ new Set();
-    for (const msg of messages) {
+    for (const msg of messages2) {
       if (msg.sender) senders.add(msg.sender);
       if (msg.channel) channelSet.add(msg.channel);
     }
@@ -1188,7 +1749,7 @@ var DeliveryManager = class {
       if (ch !== "unknown") typingMap.set(ch, baseName, { persistent: true });
     }
     const seenConvIds = /* @__PURE__ */ new Set();
-    for (const msg of messages) {
+    for (const msg of messages2) {
       if (msg.payload.conversationId && !seenConvIds.has(msg.payload.conversationId)) {
         seenConvIds.add(msg.payload.conversationId);
         typingMap.set(`volute:${msg.payload.conversationId}`, baseName, { persistent: true });
@@ -1209,10 +1770,10 @@ var DeliveryManager = class {
         try {
           const db = await getDb();
           await db.delete(deliveryQueue).where(
-            and(
-              eq(deliveryQueue.mind, baseName),
-              eq(deliveryQueue.session, session),
-              eq(deliveryQueue.status, "pending")
+            and3(
+              eq3(deliveryQueue.mind, baseName),
+              eq3(deliveryQueue.session, session),
+              eq3(deliveryQueue.status, "pending")
             )
           );
         } catch (err) {
@@ -1310,24 +1871,24 @@ var DeliveryManager = class {
   flushBatch(mindName, session, extra, interruptOverride) {
     const bufferKey = `${mindName}:${session}`;
     const buffer = this.batchBuffers.get(bufferKey);
-    const messages = [];
+    const messages2 = [];
     if (buffer) {
       if (buffer.debounceTimer) clearTimeout(buffer.debounceTimer);
       if (buffer.maxWaitTimer) clearTimeout(buffer.maxWaitTimer);
       buffer.debounceTimer = null;
       buffer.maxWaitTimer = null;
-      messages.push(...buffer.messages.splice(0));
+      messages2.push(...buffer.messages.splice(0));
       this.batchBuffers.delete(bufferKey);
     }
-    if (extra) messages.push(...extra);
-    if (messages.length === 0) return;
+    if (extra) messages2.push(...extra);
+    if (messages2.length === 0) return;
     const [baseName] = mindName.split("@", 2);
     const config = getRoutingConfig(baseName);
     const sessionConfig = resolveDeliveryMode(config, session);
     dlog2.info(
-      `flushing batch for ${mindName}/${session}: ${messages.length} messages${interruptOverride ? " (new-speaker interrupt)" : ""}`
+      `flushing batch for ${mindName}/${session}: ${messages2.length} messages${interruptOverride ? " (new-speaker interrupt)" : ""}`
     );
-    this.deliverBatchToMind(mindName, session, messages, sessionConfig, interruptOverride).catch(
+    this.deliverBatchToMind(mindName, session, messages2, sessionConfig, interruptOverride).catch(
       (err) => {
         dlog2.warn(`failed to flush batch for ${mindName}/${session}`, logger_default.errorData(err));
       }
@@ -1338,14 +1899,14 @@ var DeliveryManager = class {
     await this.persistToQueue(baseName, session, payload, "gated");
     try {
       const db = await getDb();
-      const count = await db.select({ count: sql`count(*)` }).from(deliveryQueue).where(
-        and(
-          eq(deliveryQueue.mind, baseName),
-          eq(deliveryQueue.channel, payload.channel),
-          eq(deliveryQueue.status, "gated")
+      const count2 = await db.select({ count: sql2`count(*)` }).from(deliveryQueue).where(
+        and3(
+          eq3(deliveryQueue.mind, baseName),
+          eq3(deliveryQueue.channel, payload.channel),
+          eq3(deliveryQueue.status, "gated")
         )
       );
-      if ((count[0]?.count ?? 0) <= 1) {
+      if ((count2[0]?.count ?? 0) <= 1) {
         await this.sendInviteNotification(mindName, payload);
       }
     } catch (err) {
@@ -1397,6 +1958,90 @@ var DeliveryManager = class {
       );
     }
   }
+  async enrichWithProfiles(mindName, session, payload) {
+    if (!payload.conversationId || !payload.channel) return payload;
+    const mindSessions = this.sessionStates.get(mindName);
+    const state = mindSessions?.get(session);
+    if (!state) return payload;
+    const channelKey = payload.channel;
+    if (state.seenChannelProfiles.has(channelKey)) return payload;
+    try {
+      const participants = await getParticipants(payload.conversationId);
+      const profiles = participants.map((p) => ({
+        username: p.username,
+        userType: p.userType,
+        displayName: p.displayName,
+        description: p.description
+      }));
+      const avatarBlocks = await this.loadAvatarBlocks(participants);
+      state.seenChannelProfiles.add(channelKey);
+      const enriched = { ...payload, participantProfiles: profiles };
+      if (avatarBlocks.length > 0) {
+        const existing = Array.isArray(payload.content) ? payload.content : typeof payload.content === "string" ? [{ type: "text", text: payload.content }] : [];
+        enriched.content = [...avatarBlocks, ...existing];
+      }
+      return enriched;
+    } catch (err) {
+      dlog2.warn(`failed to fetch participant profiles for ${mindName}`, logger_default.errorData(err));
+      return payload;
+    }
+  }
+  async loadAvatarBlocks(participants) {
+    const blocks = [];
+    for (const p of participants) {
+      if (!p.avatar) continue;
+      try {
+        let filePath;
+        if (p.userType === "mind") {
+          const dir = mindDir(p.username);
+          const config = readVoluteConfig(dir);
+          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);
+        }
+        const ext = extname(filePath).toLowerCase();
+        const mimeMap = {
+          ".png": "image/png",
+          ".jpg": "image/jpeg",
+          ".jpeg": "image/jpeg",
+          ".gif": "image/gif",
+          ".webp": "image/webp"
+        };
+        const mediaType = mimeMap[ext];
+        if (!mediaType) continue;
+        const data = await readFile(filePath);
+        blocks.push(
+          { type: "text", text: `[Avatar for ${p.username}]` },
+          { type: "image", media_type: mediaType, data: data.toString("base64") }
+        );
+      } catch (err) {
+        const code = err.code;
+        if (code !== "ENOENT") {
+          dlog2.warn(`failed to load avatar for ${p.username}`, logger_default.errorData(err));
+        }
+      }
+    }
+    return blocks;
+  }
   incrementActive(mind, session, senders, channels) {
     let mindSessions = this.sessionStates.get(mind);
     if (!mindSessions) {
@@ -1408,7 +2053,8 @@ var DeliveryManager = class {
       lastDeliveredAt: 0,
       lastDeliverySenders: /* @__PURE__ */ new Set(),
       lastDeliveryChannels: /* @__PURE__ */ new Set(),
-      lastInterruptAt: 0
+      lastInterruptAt: 0,
+      seenChannelProfiles: /* @__PURE__ */ new Set()
     };
     state.activeCount++;
     state.lastDeliveredAt = Date.now();
@@ -1731,16 +2377,16 @@ async function ensureMailAddress(mindName) {
 }
 
 // src/lib/daemon/scheduler.ts
-import { resolve as resolve5 } from "path";
+import { resolve as resolve6 } from "path";
 import { CronExpressionParser } from "cron-parser";
-var slog = logger_default.child("scheduler");
+var slog2 = logger_default.child("scheduler");
 var Scheduler = class {
   schedules = /* @__PURE__ */ new Map();
   interval = null;
   lastFired = /* @__PURE__ */ new Map();
   // "mind:scheduleId" → epoch minute
   get statePath() {
-    return resolve5(voluteHome(), "scheduler-state.json");
+    return resolve6(voluteHome(), "scheduler-state.json");
   }
   start() {
     this.loadState();
@@ -1799,7 +2445,7 @@ var Scheduler = class {
         prevMinute = Math.floor(prev.getTime() / 6e4);
         cronCache.set(schedule.cron, prevMinute);
       } catch (err) {
-        slog.warn(`invalid cron "${schedule.cron}" for ${mind}:${schedule.id}`, logger_default.errorData(err));
+        slog2.warn(`invalid cron "${schedule.cron}" for ${mind}:${schedule.id}`, logger_default.errorData(err));
         return false;
       }
     }
@@ -1813,11 +2459,11 @@ var Scheduler = class {
     try {
       let text;
       if (schedule.script) {
-        const homeDir = resolve5(mindDir(mindName), "home");
+        const homeDir = resolve6(mindDir(mindName), "home");
         try {
           const output = await this.runScript(schedule.script, homeDir, mindName);
           if (!output.trim()) {
-            slog.info(`fired script "${schedule.id}" for ${mindName} (no output)`);
+            slog2.info(`fired script "${schedule.id}" for ${mindName} (no output)`);
             return;
           }
           text = output;
@@ -1825,12 +2471,12 @@ var Scheduler = class {
           const stderr = err.stderr ?? "";
           text = `[script error] ${err.message}${stderr ? `
 ${stderr}` : ""}`;
-          slog.warn(`script "${schedule.id}" failed for ${mindName}`, logger_default.errorData(err));
+          slog2.warn(`script "${schedule.id}" failed for ${mindName}`, logger_default.errorData(err));
         }
       } else if (schedule.message) {
         text = schedule.message;
       } else {
-        slog.warn(`schedule "${schedule.id}" for ${mindName} has no message or script`);
+        slog2.warn(`schedule "${schedule.id}" for ${mindName} has no message or script`);
         return;
       }
       await this.deliver(mindName, {
@@ -1838,9 +2484,9 @@ ${stderr}` : ""}`;
         channel: "system:scheduler",
         sender: schedule.id
       });
-      slog.info(`fired "${schedule.id}" for ${mindName}`);
+      slog2.info(`fired "${schedule.id}" for ${mindName}`);
     } catch (err) {
-      slog.warn(`failed to fire "${schedule.id}" for ${mindName}`, logger_default.errorData(err));
+      slog2.warn(`failed to fire "${schedule.id}" for ${mindName}`, logger_default.errorData(err));
     }
   }
   runScript(script, cwd, mindName) {
@@ -1863,7 +2509,7 @@ function getScheduler() {
 
 // src/lib/daemon/token-budget.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve6 } from "path";
+import { resolve as resolve7 } from "path";
 var tlog = logger_default.child("token-budget");
 var DEFAULT_BUDGET_PERIOD_MINUTES = 60;
 var MAX_QUEUE_SIZE = 100;
@@ -1937,9 +2583,9 @@ var TokenBudget = class {
   drain(mind) {
     const state = this.budgets.get(mind);
     if (!state) return [];
-    const messages = state.queue;
+    const messages2 = state.queue;
     state.queue = [];
-    return messages;
+    return messages2;
   }
   getUsage(mind) {
     const state = this.budgets.get(mind);
@@ -1981,7 +2627,7 @@ var TokenBudget = class {
     this.dirty.clear();
   }
   budgetStatePath(mind) {
-    return resolve6(stateDir(mind), "budget.json");
+    return resolve7(stateDir(mind), "budget.json");
   }
   saveBudgetState(mind, state) {
     try {
@@ -2020,8 +2666,8 @@ var TokenBudget = class {
       return null;
     }
   }
-  async replay(mindName, messages) {
-    const summary = messages.map((m) => {
+  async replay(mindName, messages2) {
+    const summary = messages2.map((m) => {
       const from = m.sender ? `[${m.sender}]` : "";
       const ch = m.channel ? `(${m.channel})` : "";
       return `${from}${ch} ${m.textContent}`;
@@ -2031,7 +2677,7 @@ var TokenBudget = class {
         content: [
           {
             type: "text",
-            text: `[Budget replay] ${messages.length} queued message(s) from the previous budget period:
+            text: `[Budget replay] ${messages2.length} queued message(s) from the previous budget period:
 
 ${summary}`
           }
@@ -2039,11 +2685,11 @@ ${summary}`
         channel: "system:budget-replay",
         sender: "system"
       });
-      tlog.info(`replayed ${messages.length} queued message(s) for ${mindName}`);
+      tlog.info(`replayed ${messages2.length} queued message(s) for ${mindName}`);
     } catch (err) {
       tlog.warn(`failed to replay for ${mindName}`, logger_default.errorData(err));
       const state = this.budgets.get(mindName);
-      if (state) state.queue.push(...messages);
+      if (state) state.queue.push(...messages2);
     }
   }
 };
@@ -2078,6 +2724,11 @@ async function startMindFull(name) {
     (err) => logger_default.error(`failed to ensure mail address for ${baseName}`, logger_default.errorData(err))
   );
   const config = readVoluteConfig(dir);
+  if (config) {
+    syncMindProfile(baseName, config.profile ?? {}).catch(
+      (err) => logger_default.error(`failed to sync profile for ${baseName}`, logger_default.errorData(err))
+    );
+  }
   if (config?.tokenBudget) {
     getTokenBudget().setBudget(
       baseName,
@@ -2122,7 +2773,7 @@ async function stopMindFull(name) {
 }
 
 // src/lib/daemon/sleep-manager.ts
-var slog2 = logger_default.child("sleep");
+var slog3 = logger_default.child("sleep");
 function defaultState() {
   return {
     sleeping: false,
@@ -2158,7 +2809,7 @@ var SleepManager = class {
   unsubActivity = null;
   transitioning = /* @__PURE__ */ new Set();
   get statePath() {
-    return resolve7(voluteHome(), "sleep-state.json");
+    return resolve8(voluteHome(), "sleep-state.json");
   }
   start() {
     this.loadState();
@@ -2181,7 +2832,7 @@ var SleepManager = class {
         }
       }
     } catch (err) {
-      slog2.warn("failed to load sleep state", logger_default.errorData(err));
+      slog3.warn("failed to load sleep state", logger_default.errorData(err));
     }
   }
   saveState() {
@@ -2193,7 +2844,7 @@ var SleepManager = class {
       writeFileSync3(this.statePath, `${JSON.stringify(data, null, 2)}
 `);
     } catch (err) {
-      slog2.error("failed to save sleep state", logger_default.errorData(err));
+      slog3.error("failed to save sleep state", logger_default.errorData(err));
     }
   }
   // --- Public API ---
@@ -2240,7 +2891,7 @@ var SleepManager = class {
           content: preSleepMsg
         });
       } catch (err) {
-        slog2.error(`failed to persist pre-sleep message for ${name}`, logger_default.errorData(err));
+        slog3.error(`failed to persist pre-sleep message for ${name}`, logger_default.errorData(err));
       }
       try {
         await fetch(`http://127.0.0.1:${entry.port}/message`, {
@@ -2252,7 +2903,7 @@ var SleepManager = class {
           })
         });
       } catch (err) {
-        slog2.warn(`failed to send pre-sleep message to ${name}`, logger_default.errorData(err));
+        slog3.warn(`failed to send pre-sleep message to ${name}`, logger_default.errorData(err));
       }
       await this.waitForIdle(name, 12e4);
       await new Promise((r) => setTimeout(r, 3e3));
@@ -2260,7 +2911,7 @@ var SleepManager = class {
       await this.killOrphanOnPort(entry.port);
       await this.archiveSessions(name);
       this.markSleeping(name, opts);
-      slog2.info(`${name} is now sleeping`);
+      slog3.info(`${name} is now sleeping`);
     } finally {
       this.transitioning.delete(name);
     }
@@ -2286,7 +2937,7 @@ var SleepManager = class {
       try {
         await wakeMind(name);
       } catch (err) {
-        slog2.error(`failed to wake ${name}`, logger_default.errorData(err));
+        slog3.error(`failed to wake ${name}`, logger_default.errorData(err));
         return;
       }
       const entry = findMind(name);
@@ -2318,7 +2969,7 @@ var SleepManager = class {
           content: summaryText
         });
       } catch (err) {
-        slog2.error(`failed to persist wake summary for ${name}`, logger_default.errorData(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`, {
@@ -2330,16 +2981,16 @@ var SleepManager = class {
           })
         });
       } catch (err) {
-        slog2.warn(`failed to deliver wake summary to ${name}`, logger_default.errorData(err));
+        slog3.warn(`failed to deliver wake summary to ${name}`, logger_default.errorData(err));
       }
       const flushed = await this.flushQueuedMessages(name);
       if (flushed > 0) {
-        slog2.info(`flushed ${flushed} queued message(s) for ${name}`);
+        slog3.info(`flushed ${flushed} queued message(s) for ${name}`);
       }
       if (!opts?.trigger) {
         this.markAwake(name);
       }
-      slog2.info(`${name} is now awake${opts?.trigger ? " (trigger wake)" : ""}`);
+      slog3.info(`${name} is now awake${opts?.trigger ? " (trigger wake)" : ""}`);
     } finally {
       this.transitioning.delete(name);
     }
@@ -2394,20 +3045,20 @@ var SleepManager = class {
   async flushQueuedMessages(name) {
     try {
       const db = await getDb();
-      const rows = await db.select().from(deliveryQueue).where(and2(eq2(deliveryQueue.mind, name), eq2(deliveryQueue.status, "sleep-queued"))).all();
+      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-FHV4NO2F.js");
+      const { deliverMessage: deliverMessage2 } = await import("./message-delivery-XMGV3FUM.js");
       const delivered = [];
       for (const row of rows) {
         try {
           await deliverMessage2(name, JSON.parse(row.payload));
           delivered.push(row.id);
         } catch (err) {
-          slog2.warn(`failed to flush queued message ${row.id} for ${name}`, logger_default.errorData(err));
+          slog3.warn(`failed to flush queued message ${row.id} for ${name}`, logger_default.errorData(err));
         }
       }
       if (delivered.length > 0) {
-        await db.delete(deliveryQueue).where(inArray(deliveryQueue.id, delivered));
+        await db.delete(deliveryQueue).where(inArray2(deliveryQueue.id, delivered));
       }
       const state = this.states.get(name);
       if (state) {
@@ -2415,7 +3066,7 @@ var SleepManager = class {
       }
       return delivered.length;
     } catch (err) {
-      slog2.warn(`failed to flush queued messages for ${name}`, logger_default.errorData(err));
+      slog3.warn(`failed to flush queued messages for ${name}`, logger_default.errorData(err));
       return 0;
     }
   }
@@ -2443,7 +3094,7 @@ var SleepManager = class {
       const interval = CronExpressionParser2.parse(config.schedule.wake);
       return interval.next().toDate().toISOString();
     } catch (err) {
-      slog2.warn(`invalid wake cron "${config.schedule.wake}"`, logger_default.errorData(err));
+      slog3.warn(`invalid wake cron "${config.schedule.wake}"`, logger_default.errorData(err));
       return null;
     }
   }
@@ -2460,7 +3111,7 @@ var SleepManager = class {
         const wakeAt = new Date(state.voluntaryWakeAt);
         if (now >= wakeAt) {
           this.initiateWake(entry.name).catch(
-            (err) => slog2.error(`failed voluntary wake for ${entry.name}`, logger_default.errorData(err))
+            (err) => slog3.error(`failed voluntary wake for ${entry.name}`, logger_default.errorData(err))
           );
           continue;
         }
@@ -2469,7 +3120,7 @@ var SleepManager = class {
         const wakeAt = new Date(state.scheduledWakeAt);
         if (now >= wakeAt) {
           this.initiateWake(entry.name).catch(
-            (err) => slog2.error(`failed scheduled wake for ${entry.name}`, logger_default.errorData(err))
+            (err) => slog3.error(`failed scheduled wake for ${entry.name}`, logger_default.errorData(err))
           );
           continue;
         }
@@ -2477,7 +3128,7 @@ var SleepManager = class {
       if (!state?.sleeping && entry.running) {
         if (this.shouldSleep(config.schedule.sleep, epochMinute)) {
           this.initiateSleep(entry.name).catch(
-            (err) => slog2.error(`failed to initiate sleep for ${entry.name}`, logger_default.errorData(err))
+            (err) => slog3.error(`failed to initiate sleep for ${entry.name}`, logger_default.errorData(err))
           );
         }
       }
@@ -2490,22 +3141,22 @@ var SleepManager = class {
       const prevMinute = Math.floor(prev.getTime() / 6e4);
       return prevMinute === epochMinute;
     } catch (err) {
-      slog2.warn(`invalid sleep cron "${cronExpr}"`, logger_default.errorData(err));
+      slog3.warn(`invalid sleep cron "${cronExpr}"`, logger_default.errorData(err));
       return false;
     }
   }
   async waitForIdle(name, timeoutMs) {
-    return new Promise((resolve8) => {
+    return new Promise((resolve9) => {
       const timeout = setTimeout(() => {
         unsub();
-        resolve8();
+        resolve9();
       }, timeoutMs);
       const unsub = subscribe((event) => {
         if (event.mind !== name) return;
         if (event.type === "mind_done" || event.type === "mind_idle") {
           clearTimeout(timeout);
           unsub();
-          resolve8();
+          resolve9();
         }
       });
     });
@@ -2513,34 +3164,34 @@ var SleepManager = class {
   async archiveSessions(name) {
     const dir = mindDir(name);
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 16);
-    const sessionsDir = resolve7(dir, ".mind", "sessions");
+    const sessionsDir = resolve8(dir, ".mind", "sessions");
     if (existsSync5(sessionsDir)) {
-      const archiveDir = resolve7(sessionsDir, "archive");
+      const archiveDir = resolve8(sessionsDir, "archive");
       mkdirSync3(archiveDir, { recursive: true });
       for (const file of readdirSync2(sessionsDir)) {
         if (file === "archive" || !file.endsWith(".json")) continue;
-        const src = resolve7(sessionsDir, file);
+        const src = resolve8(sessionsDir, file);
         const base = file.replace(/\.json$/, "");
-        const dest = resolve7(archiveDir, `${base}-${timestamp}.json`);
+        const dest = resolve8(archiveDir, `${base}-${timestamp}.json`);
         try {
           renameSync(src, dest);
         } catch (err) {
-          slog2.warn(`failed to archive session ${file} for ${name}`, logger_default.errorData(err));
+          slog3.warn(`failed to archive session ${file} for ${name}`, logger_default.errorData(err));
         }
       }
     }
-    const piSessionsDir = resolve7(dir, ".mind", "pi-sessions");
+    const piSessionsDir = resolve8(dir, ".mind", "pi-sessions");
     if (existsSync5(piSessionsDir)) {
-      const archiveDir = resolve7(piSessionsDir, "archive");
+      const archiveDir = resolve8(piSessionsDir, "archive");
       mkdirSync3(archiveDir, { recursive: true });
       for (const entry of readdirSync2(piSessionsDir, { withFileTypes: true })) {
         if (entry.name === "archive" || !entry.isDirectory()) continue;
-        const src = resolve7(piSessionsDir, entry.name);
-        const dest = resolve7(archiveDir, `${entry.name}-${timestamp}`);
+        const src = resolve8(piSessionsDir, entry.name);
+        const dest = resolve8(archiveDir, `${entry.name}-${timestamp}`);
         try {
           renameSync(src, dest);
         } catch (err) {
-          slog2.warn(`failed to archive pi-session ${entry.name} for ${name}`, logger_default.errorData(err));
+          slog3.warn(`failed to archive pi-session ${entry.name} for ${name}`, logger_default.errorData(err));
         }
       }
     }
@@ -2548,18 +3199,18 @@ var SleepManager = class {
   async buildQueuedSummary(name) {
     try {
       const db = await getDb();
-      const rows = await db.select({ channel: deliveryQueue.channel }).from(deliveryQueue).where(and2(eq2(deliveryQueue.mind, name), eq2(deliveryQueue.status, "sleep-queued"))).all();
-      if (rows.length === 0) return "No messages while you slept.";
+      const rows = await db.select({ channel: deliveryQueue.channel }).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();
       for (const row of rows) {
         const ch = row.channel ?? "unknown";
         channelCounts.set(ch, (channelCounts.get(ch) ?? 0) + 1);
       }
-      const parts = [...channelCounts.entries()].map(([ch, count]) => `${count} on ${ch}`);
-      return `${rows.length} message${rows.length === 1 ? "" : "s"} while you slept (${parts.join(", ")}). Ask if you want them delivered.`;
+      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.`;
     } catch (err) {
-      slog2.warn(`failed to build queued summary for ${name}`, logger_default.errorData(err));
-      return "No messages while you slept.";
+      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.";
     }
   }
   /**
@@ -2573,7 +3224,7 @@ var SleepManager = class {
     } catch {
       return;
     }
-    slog2.warn(`orphan process found on port ${port} after sleep, killing`);
+    slog3.warn(`orphan process found on port ${port} after sleep, killing`);
     const execFileAsync = promisify(execFile);
     try {
       const { stdout } = await execFileAsync("lsof", ["-ti", `:${port}`, "-sTCP:LISTEN"]);
@@ -2584,7 +3235,7 @@ var SleepManager = class {
             process.kill(pid, "SIGTERM");
           } catch (err) {
             if (err.code !== "ESRCH") {
-              slog2.warn(`failed to kill orphan pid ${pid}`, logger_default.errorData(err));
+              slog3.warn(`failed to kill orphan pid ${pid}`, logger_default.errorData(err));
             }
           }
         }
@@ -2616,7 +3267,7 @@ var SleepManager = class {
           }
         }
       } catch (err) {
-        slog2.warn(`failed to kill orphan on port ${port} via /proc`, logger_default.errorData(err));
+        slog3.warn(`failed to kill orphan on port ${port} via /proc`, logger_default.errorData(err));
       }
     }
     await new Promise((r) => setTimeout(r, 1e3));
@@ -2626,7 +3277,7 @@ var SleepManager = class {
     if (!state?.sleeping || !state.wokenByTrigger) return;
     if (this.transitioning.has(event.mind)) return;
     if (event.type === "mind_idle") {
-      slog2.info(`${event.mind} going back to sleep after trigger wake`);
+      slog3.info(`${event.mind} going back to sleep after trigger wake`);
       state.wokenByTrigger = false;
       this.transitioning.add(event.mind);
       sleepMind(event.mind).then(() => this.archiveSessions(event.mind)).then(() => {
@@ -2635,9 +3286,9 @@ var SleepManager = class {
         const sleepConfig = this.getSleepConfig(event.mind);
         state.scheduledWakeAt = this.getNextWakeTime(sleepConfig);
         this.saveState();
-        slog2.info(`${event.mind} returned to sleep`);
+        slog3.info(`${event.mind} returned to sleep`);
       }).catch((err) => {
-        slog2.error(`failed to return ${event.mind} to sleep`, logger_default.errorData(err));
+        slog3.error(`failed to return ${event.mind} to sleep`, logger_default.errorData(err));
       }).finally(() => {
         this.transitioning.delete(event.mind);
       });
@@ -2661,6 +3312,21 @@ function getSleepManagerIfReady() {
 export {
   initConnectorManager,
   getConnectorManager,
+  createUser,
+  verifyUser,
+  getUser,
+  getUserByUsername,
+  listUsers,
+  listPendingUsers,
+  listUsersByType,
+  getOrCreateMindUser,
+  deleteMindUser,
+  changePassword,
+  approveUser,
+  countAdmins,
+  setUserRole,
+  deleteUser,
+  updateUserProfile,
   stopAllWatchers,
   getCachedSites,
   getCachedRecentPages,
@@ -2677,8 +3343,31 @@ export {
   getSleepManagerIfReady,
   subscribe2 as subscribe,
   publish2 as publish,
+  getWebhookUrl,
+  getAuthHeaders,
+  fireWebhook,
+  initWebhook,
   subscribe3 as subscribe2,
   publish3 as publish2,
+  createConversation,
+  getConversation,
+  getParticipants,
+  isParticipant,
+  listConversationsForUser,
+  isParticipantOrOwner,
+  deleteConversationForUser,
+  addMessage,
+  getMessages,
+  getMessagesPaginated,
+  listConversationsWithParticipants,
+  findDMConversation,
+  createChannel,
+  getChannelByName,
+  listChannels,
+  joinChannel,
+  leaveChannel,
+  getUnreadCounts,
+  markConversationRead,
   getTypingMap,
   publishTypingForChannels,
   extractTextContent,