volute 0.35.0 → 0.37.0

package/dist/{chunk-WZRZFFCL.js → chunk-5DPRTREW.js}

@@ -1,24 +1,25 @@
 #!/usr/bin/env node
 import {
   subscribe
-} from "./chunk-CORXD635.js";
+} from "./chunk-N42QMDID.js";
 import {
   logger_default
-} from "./chunk-BKF4WQCY.js";
+} from "./chunk-T2TP6ZC6.js";
 import {
   getDb
-} from "./chunk-BDYXIWA5.js";
+} from "./chunk-2NHRJ3YO.js";
 import {
+  channels,
   conversationParticipants,
   conversationReads,
   conversations,
   messages,
   users
-} from "./chunk-5N7Y5WAM.js";
+} from "./chunk-CJ26DXZL.js";
 
 // packages/daemon/src/lib/events/conversations.ts
 import { randomUUID } from "crypto";
-import { and, desc, eq, inArray, isNull, lt, sql } from "drizzle-orm";
+import { aliasedTable, and, desc, eq, inArray, lt, sql } from "drizzle-orm";
 
 // packages/daemon/src/lib/webhook.ts
 var slog = logger_default.child("webhook");
@@ -111,19 +112,14 @@ function publish(conversationId, event) {
 }
 
 // packages/daemon/src/lib/events/conversations.ts
-async function createConversation(mindName, channel, opts) {
+async function createConversation(opts) {
   const db = await getDb();
   const id = randomUUID();
   const type = opts?.type ?? "dm";
-  const name = opts?.name ?? null;
   await db.insert(conversations).values({
     id,
-    mind_name: mindName,
-    channel,
     type,
-    name,
-    user_id: opts?.userId ?? null,
-    title: opts?.title ?? null
+    user_id: opts?.userId ?? null
   });
   if (opts?.participantIds && opts.participantIds.length > 0) {
     await db.insert(conversationParticipants).values(
@@ -136,34 +132,18 @@ async function createConversation(mindName, channel, opts) {
   }
   fireWebhook({
     event: "conversation_created",
-    mind: mindName ?? "",
-    data: { id, mindName, channel, type, name, title: opts?.title ?? null }
+    mind: "",
+    data: { id, type }
   });
   return {
     id,
-    mind_name: mindName,
-    channel,
     type,
-    name,
     user_id: opts?.userId ?? null,
-    title: opts?.title ?? null,
     private: 0,
     created_at: (/* @__PURE__ */ new Date()).toISOString(),
     updated_at: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-async function getOrCreateConversation(mindName, channel, opts) {
-  const db = await getDb();
-  const existing = await db.select().from(conversations).where(
-    and(
-      eq(conversations.mind_name, mindName),
-      eq(conversations.channel, channel),
-      eq(conversations.type, "dm")
-    )
-  ).orderBy(desc(conversations.updated_at)).limit(1).get();
-  if (existing) return existing;
-  return createConversation(mindName, channel, opts);
-}
 async function getConversation(id) {
   const db = await getDb();
   const row = await db.select().from(conversations).where(eq(conversations.id, id)).get();
@@ -236,13 +216,6 @@ async function addMessage(conversationId, role, senderName, content, opts) {
     turn_id: opts?.turnId ?? null
   }).returning({ id: messages.id, created_at: messages.created_at });
   await db.update(conversations).set({ updated_at: sql`datetime('now')` }).where(eq(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(and(eq(conversations.id, conversationId), isNull(conversations.title)));
-    }
-  }
   const msg = {
     id: result.id,
     conversation_id: conversationId,
@@ -259,10 +232,9 @@ async function addMessage(conversationId, role, senderName, content, opts) {
     content: msg.content,
     createdAt: msg.created_at
   });
-  const conv = await db.select({ mind_name: conversations.mind_name }).from(conversations).where(eq(conversations.id, conversationId)).get();
   fireWebhook({
     event: "message_created",
-    mind: conv?.mind_name ?? "",
+    mind: "",
     data: {
       conversationId,
       messageId: result.id,
@@ -274,10 +246,10 @@ async function addMessage(conversationId, role, senderName, content, opts) {
   });
   return msg;
 }
-async function getMessages(conversationId) {
+async function getMessages(conversationId, limit = 200) {
   const db = await getDb();
-  const rows = await db.select().from(messages).where(eq(messages.conversation_id, conversationId)).orderBy(messages.created_at).all();
-  return rows.map(parseMessageRow);
+  const rows = await db.select().from(messages).where(eq(messages.conversation_id, conversationId)).orderBy(desc(messages.id)).limit(limit).all();
+  return rows.reverse().map(parseMessageRow);
 }
 async function getMessagesPaginated(conversationId, opts) {
   const db = await getDb();
@@ -304,8 +276,7 @@ function parseMessageRow(row) {
   }
   return { ...row, role: row.role, content };
 }
-async function listConversationsWithParticipants(userId) {
-  const convs = await listConversationsForUser(userId);
+async function enrichConversations(convs) {
   if (convs.length === 0) return [];
   const db = await getDb();
   const convIds = convs.map((c) => c.id);
@@ -317,168 +288,93 @@ async function listConversationsWithParticipants(userId) {
     role: conversationParticipants.role,
     displayName: users.display_name,
     description: users.description,
-    avatar: users.avatar
-  }).from(conversationParticipants).innerJoin(users, eq(conversationParticipants.user_id, users.id)).where(inArray(conversationParticipants.conversation_id, convIds));
+    avatar: users.avatar,
+    channelName: channels.name
+  }).from(conversationParticipants).innerJoin(users, eq(conversationParticipants.user_id, users.id)).leftJoin(channels, eq(channels.conversation_id, conversationParticipants.conversation_id)).where(inArray(conversationParticipants.conversation_id, convIds));
   const byConv = /* @__PURE__ */ new Map();
+  const channelNames = /* @__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
-    });
+    if (!arr.some((p) => p.userId === r.userId)) {
+      arr.push({
+        userId: r.userId,
+        username: r.username,
+        userType: r.userType,
+        role: r.role,
+        displayName: r.displayName,
+        description: r.description,
+        avatar: r.avatar
+      });
+    }
+    if (r.channelName && !channelNames.has(r.conversationId)) {
+      channelNames.set(r.conversationId, r.channelName);
+    }
   }
-  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 msgRows = await db.select().from(messages).where(
+    sql`${messages.id} IN (SELECT MAX(id) FROM ${messages} WHERE ${messages.conversation_id} IN ${convIds} GROUP BY ${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
-      });
+  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,
+    channel_name: channelNames.get(c.id) ?? null,
     participants: byConv.get(c.id) ?? [],
     lastMessage: byLastMsg.get(c.id)
   }));
 }
-async function findDMConversation(mindName, participantIds) {
+async function listConversationsWithParticipants(userId) {
+  const convs = await listConversationsForUser(userId);
+  return enrichConversations(convs);
+}
+async function findDMConversation(participantIds) {
   const db = await getDb();
-  const mindConvs = await db.select({ id: conversations.id }).from(conversations).where(and(eq(conversations.mind_name, mindName), eq(conversations.type, "dm"))).all();
-  for (const conv of mindConvs) {
-    const rows = await db.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(eq(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;
+  const [id1, id2] = participantIds;
+  const cp2 = aliasedTable(conversationParticipants, "cp2");
+  const row = await db.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).innerJoin(cp2, eq(conversationParticipants.conversation_id, cp2.conversation_id)).innerJoin(conversations, eq(conversations.id, conversationParticipants.conversation_id)).where(
+    and(
+      eq(conversationParticipants.user_id, id1),
+      eq(cp2.user_id, id2),
+      eq(conversations.type, "dm"),
+      sql`(SELECT COUNT(*) FROM conversation_participants cp3 WHERE cp3.conversation_id = ${conversations.id}) = 2`
+    )
+  ).get();
+  return row?.conversation_id ?? null;
 }
 async function listConversationsForMind(mindName) {
   const db = await getDb();
-  const byName = await db.select().from(conversations).where(eq(conversations.mind_name, mindName)).orderBy(desc(conversations.updated_at)).all();
   const mindUser = await db.select({ id: users.id }).from(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind"))).get();
-  const byNameIds = new Set(byName.map((c) => c.id));
-  let byParticipation = [];
-  if (mindUser) {
-    const participantRows = await db.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(eq(conversationParticipants.user_id, mindUser.id)).all();
-    const extraIds = participantRows.map((r) => r.conversation_id).filter((id) => !byNameIds.has(id));
-    if (extraIds.length > 0) {
-      byParticipation = await db.select().from(conversations).where(inArray(conversations.id, extraIds)).orderBy(desc(conversations.updated_at)).all();
-    }
-  }
-  const convs = [...byName, ...byParticipation].sort(
-    (a, b) => new Date(b.updated_at).getTime() - new Date(a.updated_at).getTime()
-  );
-  if (convs.length === 0) return [];
-  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, eq(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)
-  }));
+  if (!mindUser) return [];
+  const participantRows = await db.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(eq(conversationParticipants.user_id, mindUser.id)).all();
+  if (participantRows.length === 0) return [];
+  const convIds = participantRows.map((r) => r.conversation_id);
+  const convs = await db.select().from(conversations).where(inArray(conversations.id, convIds)).orderBy(desc(conversations.updated_at)).all();
+  return enrichConversations(convs);
 }
 async function isConversationForMind(mindName, conversationId) {
   const db = await getDb();
-  const byName = await db.select({ id: conversations.id }).from(conversations).where(and(eq(conversations.id, conversationId), eq(conversations.mind_name, mindName))).get();
-  if (byName) return true;
   const mindUser = await db.select({ id: users.id }).from(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind"))).get();
   if (!mindUser) return false;
-  const participant = await db.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(
-    and(
-      eq(conversationParticipants.conversation_id, conversationId),
-      eq(conversationParticipants.user_id, mindUser.id)
-    )
-  ).get();
-  return !!participant;
+  return isParticipant(conversationId, mindUser.id);
 }
 async function setConversationPrivate(id, isPrivate) {
   const db = await getDb();
@@ -488,23 +384,84 @@ async function deleteConversation(id) {
   const db = await getDb();
   await db.delete(conversations).where(eq(conversations.id, id));
 }
-async function createChannel(name, creatorId) {
+async function createChannel(name, creatorId, settings) {
   const participantIds = creatorId ? [creatorId] : [];
-  return createConversation(null, "volute", {
+  const conv = await createConversation({
     type: "channel",
-    name,
-    title: name,
     participantIds
   });
+  const db = await getDb();
+  try {
+    const isPrivate = settings?.private ? 1 : 0;
+    await db.insert(channels).values({
+      conversation_id: conv.id,
+      name,
+      description: settings?.description ?? null,
+      rules: settings?.rules ?? null,
+      char_limit: settings?.charLimit ?? null,
+      private: isPrivate
+    });
+    if (isPrivate) {
+      await db.update(conversations).set({ private: 1 }).where(eq(conversations.id, conv.id));
+    }
+  } catch (err) {
+    try {
+      await db.delete(conversations).where(eq(conversations.id, conv.id));
+    } catch {
+    }
+    throw err;
+  }
+  return conv;
+}
+async function getChannelName(conversationId) {
+  const db = await getDb();
+  const row = await db.select({ name: channels.name }).from(channels).where(eq(channels.conversation_id, conversationId)).get();
+  return row?.name ?? null;
 }
 async function getChannelByName(name) {
   const db = await getDb();
-  const row = await db.select().from(conversations).where(and(eq(conversations.name, name), eq(conversations.type, "channel"))).get();
+  const ch = await db.select().from(channels).where(eq(channels.name, name)).get();
+  if (!ch) return null;
+  return getConversation(ch.conversation_id);
+}
+async function getChannelSettings(name) {
+  const db = await getDb();
+  const row = await db.select().from(channels).where(eq(channels.name, name)).get();
   return row ?? null;
 }
+function formatChannelSettings(row) {
+  if (!row) return null;
+  return {
+    description: row.description,
+    rules: row.rules,
+    charLimit: row.char_limit,
+    private: !!row.private
+  };
+}
 async function listChannels() {
   const db = await getDb();
-  return await db.select().from(conversations).where(eq(conversations.type, "channel")).orderBy(conversations.name).all();
+  const rows = await db.select().from(conversations).innerJoin(channels, eq(channels.conversation_id, conversations.id)).where(eq(conversations.type, "channel")).orderBy(channels.name).all();
+  return rows.map((r) => ({
+    ...r.conversations,
+    channel_name: r.channels.name
+  }));
+}
+async function updateChannelSettings(name, settings) {
+  const db = await getDb();
+  const updates = {
+    updated_at: sql`(datetime('now'))`
+  };
+  if (settings.description !== void 0) updates.description = settings.description;
+  if (settings.rules !== void 0) updates.rules = settings.rules;
+  if (settings.charLimit !== void 0) updates.char_limit = settings.charLimit;
+  if (settings.private !== void 0) updates.private = settings.private ? 1 : 0;
+  await db.update(channels).set(updates).where(eq(channels.name, name));
+  if (settings.private !== void 0) {
+    const ch = await db.select().from(channels).where(eq(channels.name, name)).get();
+    if (ch) {
+      await db.update(conversations).set({ private: settings.private ? 1 : 0 }).where(eq(conversations.id, ch.conversation_id));
+    }
+  }
 }
 async function joinChannel(conversationId, userId) {
   if (await isParticipant(conversationId, userId)) return;
@@ -556,7 +513,6 @@ export {
   subscribe2 as subscribe,
   publish,
   createConversation,
-  getOrCreateConversation,
   getConversation,
   addParticipant,
   removeParticipant,
@@ -575,8 +531,12 @@ export {
   setConversationPrivate,
   deleteConversation,
   createChannel,
+  getChannelName,
   getChannelByName,
+  getChannelSettings,
+  formatChannelSettings,
   listChannels,
+  updateChannelSettings,
   joinChannel,
   leaveChannel,
   getUnreadCounts,

package/dist/{chunk-QWTR6AWZ.js → chunk-7AZQFSOV.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   logger_default
-} from "./chunk-BKF4WQCY.js";
+} from "./chunk-T2TP6ZC6.js";
 import {
   mindDir
-} from "./chunk-BDYXIWA5.js";
+} from "./chunk-2NHRJ3YO.js";
 
 // packages/daemon/src/lib/delivery/delivery-router.ts
 import { readFileSync, statSync } from "fs";

package/dist/{chunk-BMZQYACC.js → chunk-A6FLW5XD.js}

@@ -1,19 +1,32 @@
 #!/usr/bin/env node
 import {
   voluteSystemDir
-} from "./chunk-BDYXIWA5.js";
+} from "./chunk-2NHRJ3YO.js";
 
-// packages/daemon/src/lib/setup.ts
+// packages/daemon/src/lib/config/setup.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { resolve } from "path";
 function configPath() {
   return resolve(voluteSystemDir(), "config.json");
 }
+var _cachedConfig = null;
+var CONFIG_CACHE_TTL = 2e3;
+function _resetConfigCache() {
+  _cachedConfig = null;
+}
 function readGlobalConfig() {
+  if (_cachedConfig && Date.now() - _cachedConfig.ts < CONFIG_CACHE_TTL) {
+    return { ..._cachedConfig.config };
+  }
   const path = configPath();
-  if (!existsSync(path)) return {};
+  if (!existsSync(path)) {
+    _cachedConfig = null;
+    return {};
+  }
   try {
-    return JSON.parse(readFileSync(path, "utf-8"));
+    const config = JSON.parse(readFileSync(path, "utf-8"));
+    _cachedConfig = { config, ts: Date.now() };
+    return config;
   } catch (err) {
     console.error(`Failed to parse ${path}: ${err instanceof Error ? err.message : err}`);
     return {};
@@ -24,6 +37,7 @@ function writeGlobalConfig(config) {
   mkdirSync(voluteSystemDir(), { recursive: true });
   writeFileSync(path, `${JSON.stringify(config, null, 2)}
 `);
+  _cachedConfig = { config, ts: Date.now() };
 }
 function isSetupComplete() {
   const config = readGlobalConfig();
@@ -47,6 +61,7 @@ function migrateSetupCompleted() {
 
 export {
   configPath,
+  _resetConfigCache,
   readGlobalConfig,
   writeGlobalConfig,
   isSetupComplete,

package/dist/{chunk-N5LMGYXX.js → chunk-BIEWHAAM.js}

@@ -2,9 +2,9 @@
 import {
   mindDir,
   stateDir
-} from "./chunk-BDYXIWA5.js";
+} from "./chunk-2NHRJ3YO.js";
 
-// packages/daemon/src/lib/archive.ts
+// packages/daemon/src/lib/mind/archive.ts
 import { execFileSync } from "child_process";
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";
 import { join, relative, resolve } from "path";

package/dist/{chunk-5N7Y5WAM.js → chunk-CJ26DXZL.js}

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 import {
   __export
-} from "./chunk-7KJOFUNN.js";
+} from "./chunk-K3NQKI34.js";
 
 // packages/daemon/src/lib/schema.ts
 var schema_exports = {};
 __export(schema_exports, {
   activity: () => activity,
+  channels: () => channels,
   conversationParticipants: () => conversationParticipants,
   conversationReads: () => conversationReads,
   conversations: () => conversations,
@@ -59,21 +60,15 @@ var conversations = sqliteTable(
   "conversations",
   {
     id: text("id").primaryKey(),
-    mind_name: text("mind_name"),
-    channel: text("channel").notNull(),
     type: text("type").notNull().default("dm"),
-    name: text("name"),
     user_id: integer("user_id").references(() => users.id),
-    title: text("title"),
     private: integer("private").notNull().default(0),
     created_at: text("created_at").notNull().default(sql`(datetime('now'))`),
     updated_at: text("updated_at").notNull().default(sql`(datetime('now'))`)
   },
   (table) => [
-    index("idx_conversations_mind_name").on(table.mind_name),
     index("idx_conversations_user_id").on(table.user_id),
-    index("idx_conversations_updated_at").on(table.updated_at),
-    uniqueIndex("idx_conversations_name").on(table.name)
+    index("idx_conversations_updated_at").on(table.updated_at)
   ]
 );
 var turns = sqliteTable(
@@ -90,7 +85,8 @@ var turns = sqliteTable(
   },
   (table) => [
     index("idx_turns_mind").on(table.mind),
-    index("idx_turns_mind_status").on(table.mind, table.status)
+    index("idx_turns_mind_status").on(table.mind, table.status),
+    index("idx_turns_mind_created_at").on(table.mind, table.created_at)
   ]
 );
 var mindHistory = sqliteTable(
@@ -112,7 +108,9 @@ var mindHistory = sqliteTable(
     index("idx_mind_history_mind").on(table.mind),
     index("idx_mind_history_mind_channel").on(table.mind, table.channel),
     index("idx_mind_history_mind_type").on(table.mind, table.type),
-    index("idx_mind_history_turn_id").on(table.turn_id)
+    index("idx_mind_history_turn_id").on(table.turn_id),
+    index("idx_mind_history_session").on(table.session),
+    index("idx_mind_history_mind_created_at").on(table.mind, table.created_at)
   ]
 );
 var conversationParticipants = sqliteTable(
@@ -161,7 +159,8 @@ var deliveryQueue = sqliteTable(
   },
   (table) => [
     index("idx_delivery_queue_mind_session").on(table.mind, table.session),
-    index("idx_delivery_queue_mind_status").on(table.mind, table.status)
+    index("idx_delivery_queue_mind_status").on(table.mind, table.status),
+    index("idx_delivery_queue_status").on(table.status)
   ]
 );
 var activity = sqliteTable(
@@ -179,7 +178,8 @@ var activity = sqliteTable(
   (table) => [
     index("idx_activity_created_at").on(table.created_at),
     index("idx_activity_mind").on(table.mind),
-    index("idx_activity_turn_id").on(table.turn_id)
+    index("idx_activity_turn_id").on(table.turn_id),
+    index("idx_activity_type").on(table.type)
   ]
 );
 var summaries = sqliteTable(
@@ -195,7 +195,8 @@ var summaries = sqliteTable(
   },
   (table) => [
     uniqueIndex("idx_summaries_unique").on(table.mind, table.period, table.period_key),
-    index("idx_summaries_mind_period").on(table.mind, table.period)
+    index("idx_summaries_mind_period").on(table.mind, table.period),
+    index("idx_summaries_mind_period_key").on(table.mind, table.period_key)
   ]
 );
 var conversationReads = sqliteTable(
@@ -209,6 +210,20 @@ var conversationReads = sqliteTable(
     uniqueIndex("idx_conversation_reads_unique").on(table.user_id, table.conversation_id)
   ]
 );
+var channels = sqliteTable(
+  "channels",
+  {
+    conversation_id: text("conversation_id").primaryKey().references(() => conversations.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    description: text("description"),
+    rules: text("rules"),
+    char_limit: integer("char_limit"),
+    private: integer("private").notNull().default(0),
+    created_at: text("created_at").notNull().default(sql`(datetime('now'))`),
+    updated_at: text("updated_at").notNull().default(sql`(datetime('now'))`)
+  },
+  (table) => [uniqueIndex("idx_channels_name").on(table.name)]
+);
 var messages = sqliteTable(
   "messages",
   {
@@ -241,6 +256,7 @@ export {
   activity,
   summaries,
   conversationReads,
+  channels,
   messages,
   schema_exports
 };

package/dist/{chunk-ZSR72JB3.js → chunk-CU6OFXMM.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// packages/daemon/src/lib/volute-config.ts
+// packages/daemon/src/lib/mind/volute-config.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, resolve } from "path";
 function readJson(path) {