volute 0.3.1 → 0.5.0

package/dist/daemon.js

@@ -1,26 +1,36 @@
 #!/usr/bin/env node
 import {
+  RotatingLog,
   clearJsonMap,
   getAgentManager,
   initAgentManager,
   loadJsonMap,
   saveJsonMap
-} from "./chunk-I6OHXCMV.js";
+} from "./chunk-MW2KFO3B.js";
 import {
-  logBuffer,
-  logger_default,
-  readNdjson
-} from "./chunk-N4YNKR3Q.js";
+  checkForUpdate,
+  checkForUpdateCached,
+  getCurrentVersion
+} from "./chunk-5X7HGB6L.js";
+import {
+  CHANNELS
+} from "./chunk-SMISE4SV.js";
+import {
+  collectPart
+} from "./chunk-B3R6L2GW.js";
 import {
   readVoluteConfig,
   writeVoluteConfig
 } from "./chunk-NETNFBA5.js";
 import {
   loadMergedEnv
-} from "./chunk-DNOXHLE5.js";
+} from "./chunk-HE67X4T6.js";
 import {
   applyIsolation
-} from "./chunk-SOZA2TLP.js";
+} from "./chunk-UAVD2AHX.js";
+import {
+  resolveVoluteBin
+} from "./chunk-5SKQ6J7T.js";
 import {
   agentDir,
   checkHealth,
@@ -34,32 +44,101 @@ import {
   setAgentRunning,
   setVariantRunning,
   voluteHome
-} from "./chunk-3C2XR4IY.js";
+} from "./chunk-UX25Z2ND.js";
 import {
   __export
 } from "./chunk-K3NQKI34.js";
 
 // src/daemon.ts
 import { randomBytes } from "crypto";
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve8 } from "path";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir } from "os";
+import { resolve as resolve10 } from "path";
+import { format } from "util";
 
 // src/lib/connector-manager.ts
 import { spawn } from "child_process";
-import {
-  createWriteStream,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  unlinkSync,
-  writeFileSync
-} from "fs";
-import { dirname, resolve } from "path";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
+import { dirname, resolve as resolve2 } from "path";
+
+// src/lib/connector-defs.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } 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: "agent"
+      },
+      {
+        name: "DISCORD_GUILD_ID",
+        required: false,
+        description: "Discord server ID (optional, for slash commands)",
+        scope: "agent"
+      }
+    ]
+  },
+  slack: {
+    displayName: "Slack",
+    description: "Connect to Slack via Socket Mode",
+    envVars: [
+      {
+        name: "SLACK_BOT_TOKEN",
+        required: true,
+        description: "Slack bot token (xoxb-...)",
+        scope: "agent"
+      },
+      {
+        name: "SLACK_APP_TOKEN",
+        required: true,
+        description: "Slack app-level token (xapp-...) for Socket Mode",
+        scope: "agent"
+      }
+    ]
+  },
+  telegram: {
+    displayName: "Telegram",
+    description: "Connect to Telegram via long polling",
+    envVars: [
+      {
+        name: "TELEGRAM_BOT_TOKEN",
+        required: true,
+        description: "Telegram bot token from BotFather",
+        scope: "agent"
+      }
+    ]
+  }
+};
+function getConnectorDef(type, connectorDir) {
+  if (BUILTIN_DEFS[type]) return BUILTIN_DEFS[type];
+  if (connectorDir) {
+    const jsonPath = resolve(connectorDir, "connector.json");
+    if (existsSync(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/connector-manager.ts
 function searchUpwards(...segments) {
   let searchDir = dirname(new URL(import.meta.url).pathname);
   for (let i = 0; i < 5; i++) {
-    const candidate = resolve(searchDir, ...segments);
-    if (existsSync(candidate)) return candidate;
+    const candidate = resolve2(searchDir, ...segments);
+    if (existsSync2(candidate)) return candidate;
     searchDir = dirname(searchDir);
   }
   return null;
@@ -85,6 +164,20 @@ var ConnectorManager = class {
       }
     }
   }
+  checkConnectorEnv(type, agentDir2) {
+    const agentConnectorDir = resolve2(agentDir2, "connectors", type);
+    const userConnectorDir = resolve2(voluteHome(), "connectors", type);
+    const connectorDir = existsSync2(agentConnectorDir) ? agentConnectorDir : existsSync2(userConnectorDir) ? userConnectorDir : void 0;
+    const def = getConnectorDef(type, connectorDir);
+    if (!def) return null;
+    const env = loadMergedEnv(agentDir2);
+    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(agentName, agentDir2, agentPort, type, daemonPort) {
     const existing = this.connectors.get(agentName)?.get(type);
     if (existing) {
@@ -106,15 +199,15 @@ var ConnectorManager = class {
       this.connectors.get(agentName)?.delete(type);
     }
     this.killOrphanConnector(agentDir2, type);
-    const agentConnector = resolve(agentDir2, "connectors", type, "index.ts");
-    const userConnector = resolve(voluteHome(), "connectors", type, "index.ts");
+    const agentConnector = resolve2(agentDir2, "connectors", type, "index.ts");
+    const userConnector = resolve2(voluteHome(), "connectors", type, "index.ts");
     const builtinConnector = this.resolveBuiltinConnector(type);
     let connectorScript;
     let runtime;
-    if (existsSync(agentConnector)) {
+    if (existsSync2(agentConnector)) {
       connectorScript = agentConnector;
-      runtime = resolve(agentDir2, "node_modules", ".bin", "tsx");
-    } else if (existsSync(userConnector)) {
+      runtime = resolve2(agentDir2, "node_modules", ".bin", "tsx");
+    } else if (existsSync2(userConnector)) {
       connectorScript = userConnector;
       runtime = this.resolveVoluteTsx();
     } else if (builtinConnector) {
@@ -123,9 +216,9 @@ var ConnectorManager = class {
     } else {
       throw new Error(`No connector code found for type: ${type}`);
     }
-    const logsDir = resolve(agentDir2, ".volute", "logs");
+    const logsDir = resolve2(agentDir2, ".volute", "logs");
     mkdirSync(logsDir, { recursive: true });
-    const logStream = createWriteStream(resolve(logsDir, `${type}.log`), { flags: "a" });
+    const logStream = new RotatingLog(resolve2(logsDir, `${type}.log`));
     const agentEnv = loadMergedEnv(agentDir2);
     const prefix = `${type.toUpperCase()}_`;
     const connectorEnv = Object.fromEntries(
@@ -137,6 +230,7 @@ var ConnectorManager = class {
         ...process.env,
         VOLUTE_AGENT_PORT: String(agentPort),
         VOLUTE_AGENT_NAME: agentName,
+        VOLUTE_AGENT_DIR: agentDir2,
         ...daemonPort ? {
           VOLUTE_DAEMON_URL: `http://127.0.0.1:${daemonPort}`,
           VOLUTE_DAEMON_TOKEN: process.env.VOLUTE_DAEMON_TOKEN
@@ -146,8 +240,12 @@ var ConnectorManager = class {
     };
     await applyIsolation(spawnOpts, agentName);
     const child = spawn(runtime, [connectorScript], spawnOpts);
+    let lastStderr = "";
     child.stdout?.pipe(logStream);
-    child.stderr?.pipe(logStream);
+    child.stderr?.on("data", (chunk) => {
+      logStream.write(chunk);
+      lastStderr = chunk.toString().trim();
+    });
     if (child.pid) {
       this.saveConnectorPid(agentDir2, type, child.pid);
     }
@@ -165,6 +263,7 @@ var ConnectorManager = class {
       if (this.shuttingDown) return;
       if (this.stopping.has(stopKey)) return;
       console.error(`[daemon] connector ${type} for ${agentName} exited with code ${code}`);
+      if (lastStderr) console.error(`[daemon] last output: ${lastStderr}`);
       const attempts = this.restartAttempts.get(stopKey) ?? 0;
       if (attempts >= MAX_RESTART_ATTEMPTS) {
         console.error(
@@ -194,19 +293,19 @@ var ConnectorManager = class {
     const stopKey = `${agentName}:${type}`;
     this.stopping.add(stopKey);
     agentMap.delete(type);
-    await new Promise((resolve9) => {
-      tracked.child.on("exit", () => resolve9());
+    await new Promise((resolve11) => {
+      tracked.child.on("exit", () => resolve11());
       try {
         tracked.child.kill("SIGTERM");
       } catch {
-        resolve9();
+        resolve11();
       }
       setTimeout(() => {
         try {
           tracked.child.kill("SIGKILL");
         } catch {
         }
-        resolve9();
+        resolve11();
       }, 5e3);
     });
     this.stopping.delete(stopKey);
@@ -238,7 +337,7 @@ var ConnectorManager = class {
     }));
   }
   connectorPidPath(agentDir2, type) {
-    return resolve(agentDir2, ".volute", "connectors", `${type}.pid`);
+    return resolve2(agentDir2, ".volute", "connectors", `${type}.pid`);
   }
   saveConnectorPid(agentDir2, type, pid) {
     const pidPath = this.connectorPidPath(agentDir2, type);
@@ -253,9 +352,9 @@ var ConnectorManager = class {
   }
   killOrphanConnector(agentDir2, type) {
     const pidPath = this.connectorPidPath(agentDir2, type);
-    if (!existsSync(pidPath)) return;
+    if (!existsSync2(pidPath)) return;
     try {
-      const pid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+      const pid = parseInt(readFileSync2(pidPath, "utf-8").trim(), 10);
       if (pid > 0) {
         process.kill(pid, "SIGTERM");
         console.error(`[daemon] killed orphan connector ${type} (pid ${pid})`);
@@ -286,7 +385,7 @@ function getConnectorManager() {
 }
 
 // src/lib/scheduler.ts
-import { resolve as resolve2 } from "path";
+import { resolve as resolve3 } from "path";
 import { CronExpressionParser } from "cron-parser";
 var Scheduler = class {
   schedules = /* @__PURE__ */ new Map();
@@ -296,7 +395,7 @@ var Scheduler = class {
   daemonPort = null;
   daemonToken = null;
   get statePath() {
-    return resolve2(voluteHome(), "scheduler-state.json");
+    return resolve3(voluteHome(), "scheduler-state.json");
   }
   start(daemonPort, daemonToken) {
     this.daemonPort = daemonPort ?? null;
@@ -374,6 +473,8 @@ var Scheduler = class {
       channel: "system:scheduler",
       sender: schedule.id
     });
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 12e4);
     try {
       let res;
       if (this.daemonPort && this.daemonToken) {
@@ -385,13 +486,15 @@ var Scheduler = class {
             Authorization: `Bearer ${this.daemonToken}`,
             Origin: daemonUrl
           },
-          body
+          body,
+          signal: controller.signal
         });
       } else {
         res = await fetch(`http://127.0.0.1:${entry.port}/message`, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
-          body
+          body,
+          signal: controller.signal
         });
       }
       if (!res.ok) {
@@ -399,8 +502,22 @@ var Scheduler = class {
       } else {
         console.error(`[scheduler] fired "${schedule.id}" for ${agentName}`);
       }
+      try {
+        const reader = res.body?.getReader();
+        if (reader) {
+          try {
+            while (!(await reader.read()).done) {
+            }
+          } finally {
+            reader.releaseLock();
+          }
+        }
+      } catch {
+      }
     } catch (err) {
       console.error(`[scheduler] failed to fire "${schedule.id}" for ${agentName}:`, err);
+    } finally {
+      clearTimeout(timeout);
     }
   }
 };
@@ -421,8 +538,8 @@ import { compareSync, hashSync } from "bcryptjs";
 import { and, count, eq } from "drizzle-orm";
 
 // src/lib/db.ts
-import { chmodSync, existsSync as existsSync2 } from "fs";
-import { dirname as dirname2, resolve as resolve3 } from "path";
+import { chmodSync, existsSync as existsSync3 } from "fs";
+import { dirname as dirname2, resolve as resolve4 } from "path";
 import { fileURLToPath } from "url";
 import { drizzle } from "drizzle-orm/libsql";
 import { migrate } from "drizzle-orm/libsql/migrator";
@@ -431,18 +548,20 @@ import { migrate } from "drizzle-orm/libsql/migrator";
 var schema_exports = {};
 __export(schema_exports, {
   agentMessages: () => agentMessages,
+  conversationParticipants: () => conversationParticipants,
   conversations: () => conversations,
   messages: () => messages,
   sessions: () => sessions,
   users: () => users
 });
 import { sql } from "drizzle-orm";
-import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
 var users = sqliteTable("users", {
   id: integer("id").primaryKey({ autoIncrement: true }),
   username: text("username").unique().notNull(),
   password_hash: text("password_hash").notNull(),
   role: text("role").notNull().default("pending"),
+  user_type: text("user_type").notNull().default("human"),
   created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
 });
 var conversations = sqliteTable(
@@ -478,6 +597,19 @@ var agentMessages = sqliteTable(
     index("idx_agent_messages_channel").on(table.agent, table.channel)
   ]
 );
+var conversationParticipants = sqliteTable(
+  "conversation_participants",
+  {
+    conversation_id: text("conversation_id").notNull().references(() => conversations.id, { onDelete: "cascade" }),
+    user_id: integer("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    role: text("role").notNull().default("member"),
+    joined_at: text("joined_at").notNull().default(sql`(datetime('now'))`)
+  },
+  (table) => [
+    uniqueIndex("idx_cp_unique").on(table.conversation_id, table.user_id),
+    index("idx_cp_user_id").on(table.user_id)
+  ]
+);
 var sessions = sqliteTable("sessions", {
   id: text("id").primaryKey(),
   userId: integer("user_id").references(() => users.id, { onDelete: "cascade" }).notNull(),
@@ -498,11 +630,11 @@ var messages = sqliteTable(
 
 // src/lib/db.ts
 var __dirname = dirname2(fileURLToPath(import.meta.url));
-var migrationsFolder = existsSync2(resolve3(__dirname, "../drizzle")) ? resolve3(__dirname, "../drizzle") : resolve3(__dirname, "../../drizzle");
+var migrationsFolder = existsSync3(resolve4(__dirname, "../drizzle")) ? resolve4(__dirname, "../drizzle") : resolve4(__dirname, "../../drizzle");
 var db = null;
 async function getDb() {
   if (db) return db;
-  const dbPath = process.env.VOLUTE_DB_PATH || resolve3(voluteHome(), "volute.db");
+  const dbPath = process.env.VOLUTE_DB_PATH || resolve4(voluteHome(), "volute.db");
   db = drizzle({ connection: { url: `file:${dbPath}` }, schema: schema_exports });
   await migrate(db, { migrationsFolder });
   try {
@@ -520,12 +652,13 @@ async function getDb() {
 async function createUser(username, password) {
   const db2 = await getDb();
   const hash = hashSync(password, 10);
-  const [{ value }] = await db2.select({ value: count() }).from(users);
+  const [{ value }] = await db2.select({ value: count() }).from(users).where(eq(users.user_type, "human"));
   const role = value === 0 ? "admin" : "pending";
   const [result] = await db2.insert(users).values({ username, password_hash: hash, role }).returning({
     id: users.id,
     username: users.username,
     role: users.role,
+    user_type: users.user_type,
     created_at: users.created_at
   });
   return result;
@@ -534,6 +667,7 @@ async function verifyUser(username, password) {
   const db2 = await getDb();
   const row = await db2.select().from(users).where(eq(users.username, username)).get();
   if (!row) return null;
+  if (row.user_type === "agent") return null;
   if (!compareSync(password, row.password_hash)) return null;
   const { password_hash: _, ...user } = row;
   return user;
@@ -544,6 +678,7 @@ async function getUser(id) {
     id: users.id,
     username: users.username,
     role: users.role,
+    user_type: users.user_type,
     created_at: users.created_at
   }).from(users).where(eq(users.id, id)).get();
   return row ?? null;
@@ -554,6 +689,7 @@ async function getUserByUsername(username) {
     id: users.id,
     username: users.username,
     role: users.role,
+    user_type: users.user_type,
     created_at: users.created_at
   }).from(users).where(eq(users.username, username)).get();
   return row ?? null;
@@ -564,6 +700,7 @@ async function listUsers() {
     id: users.id,
     username: users.username,
     role: users.role,
+    user_type: users.user_type,
     created_at: users.created_at
   }).from(users).orderBy(users.created_at).all();
 }
@@ -573,9 +710,58 @@ async function listPendingUsers() {
     id: users.id,
     username: users.username,
     role: users.role,
+    user_type: users.user_type,
     created_at: users.created_at
   }).from(users).where(eq(users.role, "pending")).orderBy(users.created_at).all();
 }
+async function listUsersByType(userType) {
+  const db2 = await getDb();
+  return db2.select({
+    id: users.id,
+    username: users.username,
+    role: users.role,
+    user_type: users.user_type,
+    created_at: users.created_at
+  }).from(users).where(eq(users.user_type, userType)).orderBy(users.created_at).all();
+}
+async function getOrCreateAgentUser(agentName) {
+  const db2 = await getDb();
+  const existing = await db2.select({
+    id: users.id,
+    username: users.username,
+    role: users.role,
+    user_type: users.user_type,
+    created_at: users.created_at
+  }).from(users).where(and(eq(users.username, agentName), eq(users.user_type, "agent"))).get();
+  if (existing) return existing;
+  try {
+    const [result] = await db2.insert(users).values({
+      username: agentName,
+      password_hash: "!agent",
+      role: "agent",
+      user_type: "agent"
+    }).returning({
+      id: users.id,
+      username: users.username,
+      role: users.role,
+      user_type: users.user_type,
+      created_at: users.created_at
+    });
+    return result;
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
+      const retried = await db2.select({
+        id: users.id,
+        username: users.username,
+        role: users.role,
+        user_type: users.user_type,
+        created_at: users.created_at
+      }).from(users).where(and(eq(users.username, agentName), eq(users.user_type, "agent"))).get();
+      if (retried) return retried;
+    }
+    throw err;
+  }
+}
 async function approveUser(id) {
   const db2 = await getDb();
   await db2.update(users).set({ role: "user" }).where(and(eq(users.id, id), eq(users.role, "pending")));
@@ -625,7 +811,7 @@ var authMiddleware = createMiddleware(async (c, next) => {
   if (authHeader?.startsWith("Bearer ")) {
     const token = authHeader.slice(7);
     if (token && isValidDaemonToken(token)) {
-      c.set("user", { id: 0, username: "cli", role: "admin" });
+      c.set("user", { id: 0, username: "cli", role: "admin", user_type: "human" });
       await next();
       return;
     }
@@ -642,37 +828,111 @@ var authMiddleware = createMiddleware(async (c, next) => {
 });
 
 // src/web/server.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { readFile as readFile2, stat } from "fs/promises";
-import { dirname as dirname3, extname, resolve as resolve7 } from "path";
+import { dirname as dirname3, extname, resolve as resolve9 } from "path";
 import { serve } from "@hono/node-server";
 
+// src/lib/log-buffer.ts
+var LogBuffer = class {
+  entries = [];
+  maxSize = 1e3;
+  subscribers = /* @__PURE__ */ new Set();
+  append(entry) {
+    this.entries.push(entry);
+    if (this.entries.length > this.maxSize) {
+      this.entries.shift();
+    }
+    for (const sub of this.subscribers) {
+      sub(entry);
+    }
+  }
+  getEntries() {
+    return [...this.entries];
+  }
+  subscribe(fn) {
+    this.subscribers.add(fn);
+    return () => this.subscribers.delete(fn);
+  }
+};
+var logBuffer = new LogBuffer();
+
+// src/lib/logger.ts
+function write(level, msg, data) {
+  const entry = {
+    level,
+    msg,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    ...data ? { data } : {}
+  };
+  const line = JSON.stringify(entry);
+  process.stderr.write(`${line}
+`);
+  logBuffer.append(entry);
+}
+var log = {
+  info: (msg, data) => write("info", msg, data),
+  warn: (msg, data) => write("warn", msg, data),
+  error: (msg, data) => write("error", msg, data)
+};
+var logger_default = log;
+
 // src/web/app.ts
-import { Hono as Hono11 } from "hono";
+import { Hono as Hono13 } from "hono";
 import { bodyLimit } from "hono/body-limit";
 import { csrf } from "hono/csrf";
 import { HTTPException } from "hono/http-exception";
 
 // src/web/routes/agents.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, rmSync } from "fs";
-import { resolve as resolve4 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3, rmSync } from "fs";
+import { resolve as resolve5 } from "path";
 import { and as and2, desc, eq as eq3 } from "drizzle-orm";
 import { Hono } from "hono";
 import { stream } from "hono/streaming";
 
-// src/lib/channels.ts
-var CHANNELS = {
-  web: { name: "web", displayName: "Web UI", showToolCalls: true },
-  discord: { name: "discord", displayName: "Discord", showToolCalls: false },
-  cli: { name: "cli", displayName: "CLI", showToolCalls: true },
-  agent: { name: "agent", displayName: "Agent", showToolCalls: true },
-  system: { name: "system", displayName: "System", showToolCalls: false }
-};
+// src/lib/ndjson.ts
+var MAX_BUFFER_SIZE = 1e6;
+async function* readNdjson(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      if (buffer.length > MAX_BUFFER_SIZE) {
+        logger_default.warn("ndjson: buffer exceeded 1MB, resetting");
+        buffer = "";
+        continue;
+      }
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          yield JSON.parse(line);
+        } catch {
+          logger_default.warn("ndjson: skipping invalid line", { line: line.slice(0, 100) });
+        }
+      }
+    }
+    if (buffer.trim()) {
+      try {
+        yield JSON.parse(buffer);
+      } catch {
+        logger_default.warn("ndjson: skipping invalid line", { line: buffer.slice(0, 100) });
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
 
 // src/web/routes/agents.ts
 function getDaemonPort() {
   try {
-    const data = JSON.parse(readFileSync2(resolve4(voluteHome(), "daemon.json"), "utf-8"));
+    const data = JSON.parse(readFileSync3(resolve5(voluteHome(), "daemon.json"), "utf-8"));
     return data.port;
   } catch {
     return void 0;
@@ -687,10 +947,10 @@ async function getAgentStatus(name, port) {
   }
   const channels = [];
   channels.push({
-    name: CHANNELS.web.name,
-    displayName: CHANNELS.web.displayName,
+    name: CHANNELS.volute.name,
+    displayName: CHANNELS.volute.displayName,
     status: status === "running" ? "connected" : "disconnected",
-    showToolCalls: CHANNELS.web.showToolCalls
+    showToolCalls: CHANNELS.volute.showToolCalls
   });
   const connectorStatuses = getConnectorManager().getConnectorStatus(name);
   for (const cs of connectorStatuses) {
@@ -717,7 +977,7 @@ var app = new Hono().get("/", async (c) => {
   const name = c.req.param("name");
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
-  if (!existsSync3(agentDir(name))) return c.json({ error: "Agent directory missing" }, 404);
+  if (!existsSync4(agentDir(name))) return c.json({ error: "Agent directory missing" }, 404);
   const { status, channels } = await getAgentStatus(name, entry.port);
   const variants = readVariants(name);
   const manager = getAgentManager();
@@ -743,7 +1003,7 @@ var app = new Hono().get("/", async (c) => {
     if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
   } else {
     const dir = agentDir(baseName);
-    if (!existsSync3(dir)) return c.json({ error: "Agent directory missing" }, 404);
+    if (!existsSync4(dir)) return c.json({ error: "Agent directory missing" }, 404);
   }
   const manager = getAgentManager();
   if (manager.isRunning(name)) {
@@ -770,7 +1030,7 @@ var app = new Hono().get("/", async (c) => {
     if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
   } else {
     const dir = agentDir(baseName);
-    if (!existsSync3(dir)) return c.json({ error: "Agent directory missing" }, 404);
+    if (!existsSync4(dir)) return c.json({ error: "Agent directory missing" }, 404);
   }
   const manager = getAgentManager();
   const connectorManager = getConnectorManager();
@@ -825,7 +1085,7 @@ var app = new Hono().get("/", async (c) => {
   }
   removeAllVariants(name);
   removeAgent(name);
-  if (force && existsSync3(dir)) {
+  if (force && existsSync4(dir)) {
     rmSync(dir, { recursive: true, force: true });
   }
   return c.json({ ok: true });
@@ -847,14 +1107,22 @@ var app = new Hono().get("/", async (c) => {
   let parsed = null;
   try {
     parsed = JSON.parse(body);
-  } catch {
+  } catch (err) {
+    console.error(`[daemon] failed to parse message body for ${baseName}:`, err);
   }
   const channel = parsed?.channel ?? "unknown";
   const db2 = await getDb();
   if (parsed) {
     try {
       const sender = parsed.sender ?? null;
-      const content = typeof parsed.content === "string" ? parsed.content : JSON.stringify(parsed.content);
+      let content;
+      if (typeof parsed.content === "string") {
+        content = parsed.content;
+      } else if (Array.isArray(parsed.content)) {
+        content = parsed.content.filter((p) => p.type === "text" && p.text).map((p) => p.text).join("\n");
+      } else {
+        content = JSON.stringify(parsed.content);
+      }
       await db2.insert(agentMessages).values({
         agent: baseName,
         channel,
@@ -866,11 +1134,17 @@ var app = new Hono().get("/", async (c) => {
       console.error(`[daemon] failed to persist inbound message for ${baseName}:`, err);
     }
   }
-  const res = await fetch(`http://127.0.0.1:${port}/message`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body
-  });
+  let res;
+  try {
+    res = await fetch(`http://127.0.0.1:${port}/message`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body
+    });
+  } catch (err) {
+    console.error(`[daemon] agent ${name} unreachable on port ${port}:`, err);
+    return c.json({ error: "Agent is not reachable" }, 502);
+  }
   if (!res.ok) {
     return c.json({ error: `Agent responded with ${res.status}` }, res.status);
   }
@@ -878,57 +1152,39 @@ var app = new Hono().get("/", async (c) => {
     return c.json({ error: "No response body from agent" }, 502);
   }
   c.header("Content-Type", "application/x-ndjson");
+  const encoder = new TextEncoder();
   return stream(c, async (s) => {
-    const reader = res.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
     const textParts = [];
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        await s.write(value);
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() || "";
-        for (const line of lines) {
-          if (!line.trim()) continue;
-          try {
-            const event = JSON.parse(line);
-            if (event.type === "text") {
-              textParts.push(event.content);
-            }
-          } catch {
-            console.warn(`[daemon] malformed NDJSON line from ${baseName}`);
-          }
-        }
-      }
-      if (buffer.trim()) {
-        try {
-          const event = JSON.parse(buffer);
-          if (event.type === "text") {
-            textParts.push(event.content);
-          }
-        } catch {
-          console.warn(`[daemon] malformed NDJSON trailing data from ${baseName}`);
-        }
+    const toolParts = [];
+    for await (const event of readNdjson(res.body)) {
+      await s.write(encoder.encode(`${JSON.stringify(event)}
+`));
+      const part = collectPart(event);
+      if (part != null) {
+        if (event.type === "tool_use") toolParts.push(part);
+        else textParts.push(part);
       }
-      if (textParts.length > 0) {
-        try {
-          await db2.insert(agentMessages).values({
-            agent: baseName,
-            channel,
-            role: "assistant",
-            content: textParts.join("")
-          });
-        } catch (err) {
-          console.error(`[daemon] failed to persist assistant response for ${baseName}:`, err);
-        }
+    }
+    const content = [textParts.join(""), ...toolParts].filter(Boolean).join("\n");
+    if (content) {
+      try {
+        await db2.insert(agentMessages).values({
+          agent: baseName,
+          channel,
+          role: "assistant",
+          sender: baseName,
+          content
+        });
+      } catch (err) {
+        console.error(`[daemon] failed to persist assistant response for ${baseName}:`, err);
       }
-    } finally {
-      reader.releaseLock();
     }
   });
+}).get("/:name/history/channels", async (c) => {
+  const name = c.req.param("name");
+  const db2 = await getDb();
+  const rows = await db2.selectDistinct({ channel: agentMessages.channel }).from(agentMessages).where(eq3(agentMessages.agent, name));
+  return c.json(rows.map((r) => r.channel));
 }).get("/:name/history", async (c) => {
   const name = c.req.param("name");
   const channel = c.req.query("channel");
@@ -956,6 +1212,14 @@ var credentialsSchema = z.object({
 var admin = new Hono2().use(authMiddleware).get("/users", async (c) => {
   const user = c.get("user");
   if (user.role !== "admin") return c.json({ error: "Forbidden" }, 403);
+  const agents = readRegistry();
+  for (const agent of agents) {
+    await getOrCreateAgentUser(agent.name);
+  }
+  const type = c.req.query("type");
+  if (type === "human" || type === "agent") {
+    return c.json(await listUsersByType(type));
+  }
   return c.json(await listUsers());
 }).get("/users/pending", async (c) => {
   const user = c.get("user");
@@ -1008,6 +1272,8 @@ var app2 = new Hono2().post("/register", zValidator("json", credentialsSchema),
 var auth_default = app2;
 
 // src/web/routes/chat.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve6 } from "path";
 import { zValidator as zValidator2 } from "@hono/zod-validator";
 import { Hono as Hono3 } from "hono";
 import { streamSSE } from "hono/streaming";
@@ -1015,7 +1281,7 @@ import { z as z2 } from "zod";
 
 // src/lib/conversations.ts
 import { randomUUID } from "crypto";
-import { and as and3, desc as desc2, eq as eq4, isNull, sql as sql2 } from "drizzle-orm";
+import { and as and3, desc as desc2, eq as eq4, inArray, isNull, sql as sql2 } from "drizzle-orm";
 async function createConversation(agentName, channel, opts) {
   const db2 = await getDb();
   const id = randomUUID();
@@ -1026,6 +1292,15 @@ async function createConversation(agentName, channel, opts) {
     user_id: opts?.userId ?? null,
     title: opts?.title ?? null
   });
+  if (opts?.participantIds && opts.participantIds.length > 0) {
+    await db2.insert(conversationParticipants).values(
+      opts.participantIds.map((uid, i) => ({
+        conversation_id: id,
+        user_id: uid,
+        role: i === 0 ? "owner" : "member"
+      }))
+    );
+  }
   return {
     id,
     agent_name: agentName,
@@ -1036,24 +1311,44 @@ async function createConversation(agentName, channel, opts) {
     updated_at: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-async function getConversationForUser(id, userId) {
+async function getParticipants(conversationId) {
   const db2 = await getDb();
-  const row = await db2.select().from(conversations).where(and3(eq4(conversations.id, id), eq4(conversations.user_id, userId))).get();
-  return row ?? null;
+  const rows = await db2.select({
+    userId: conversationParticipants.user_id,
+    username: users.username,
+    userType: users.user_type,
+    role: conversationParticipants.role
+  }).from(conversationParticipants).innerJoin(users, eq4(conversationParticipants.user_id, users.id)).where(eq4(conversationParticipants.conversation_id, conversationId)).all();
+  return rows;
+}
+async function isParticipant(conversationId, userId) {
+  const db2 = await getDb();
+  const row = await db2.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(
+    and3(
+      eq4(conversationParticipants.conversation_id, conversationId),
+      eq4(conversationParticipants.user_id, userId)
+    )
+  ).get();
+  return row != null;
+}
+async function listConversationsForUser(userId) {
+  const db2 = await getDb();
+  const participantRows = await db2.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(eq4(conversationParticipants.user_id, userId)).all();
+  if (participantRows.length === 0) return [];
+  const convIds = participantRows.map((r) => r.conversation_id);
+  return db2.select().from(conversations).where(inArray(conversations.id, convIds)).orderBy(desc2(conversations.updated_at)).all();
+}
+async function isParticipantOrOwner(conversationId, userId) {
+  if (await isParticipant(conversationId, userId)) return true;
+  const db2 = await getDb();
+  const row = await db2.select().from(conversations).where(and3(eq4(conversations.id, conversationId), eq4(conversations.user_id, userId))).get();
+  return row != null;
 }
 async function deleteConversationForUser(id, userId) {
-  const conv = await getConversationForUser(id, userId);
-  if (!conv) return false;
+  if (!await isParticipantOrOwner(id, userId)) return false;
   await deleteConversation(id);
   return true;
 }
-async function listConversations(agentName, opts) {
-  const db2 = await getDb();
-  if (opts?.userId != null) {
-    return db2.select().from(conversations).where(and3(eq4(conversations.agent_name, agentName), eq4(conversations.user_id, opts.userId))).orderBy(desc2(conversations.updated_at)).all();
-  }
-  return db2.select().from(conversations).where(eq4(conversations.agent_name, agentName)).orderBy(desc2(conversations.updated_at)).all();
-}
 async function addMessage(conversationId, role, senderName, content) {
   const db2 = await getDb();
   const serialized = JSON.stringify(content);
@@ -1089,6 +1384,34 @@ async function getMessages(conversationId) {
     return { ...row, content };
   });
 }
+async function listConversationsWithParticipants(userId) {
+  const convs = await listConversationsForUser(userId);
+  if (convs.length === 0) return [];
+  const db2 = await getDb();
+  const convIds = convs.map((c) => c.id);
+  const rows = await db2.select({
+    conversationId: conversationParticipants.conversation_id,
+    userId: users.id,
+    username: users.username,
+    userType: users.user_type,
+    role: conversationParticipants.role
+  }).from(conversationParticipants).innerJoin(users, eq4(conversationParticipants.user_id, users.id)).where(inArray(conversationParticipants.conversation_id, convIds));
+  const byConv = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    let arr = byConv.get(r.conversationId);
+    if (!arr) {
+      arr = [];
+      byConv.set(r.conversationId, arr);
+    }
+    arr.push({
+      userId: r.userId,
+      username: r.username,
+      userType: r.userType,
+      role: r.role
+    });
+  }
+  return convs.map((c) => ({ ...c, participants: byConv.get(c.id) ?? [] }));
+}
 async function deleteConversation(id) {
   const db2 = await getDb();
   await db2.delete(conversations).where(eq4(conversations.id, id));
@@ -1098,6 +1421,7 @@ async function deleteConversation(id) {
 var chatSchema = z2.object({
   message: z2.string().optional(),
   conversationId: z2.string().optional(),
+  sender: z2.string().optional(),
   images: z2.array(
     z2.object({
       media_type: z2.string(),
@@ -1105,18 +1429,59 @@ var chatSchema = z2.object({
     })
   ).optional()
 });
+function getDaemonUrl() {
+  const data = JSON.parse(readFileSync4(resolve6(voluteHome(), "daemon.json"), "utf-8"));
+  return `http://127.0.0.1:${data.port}`;
+}
+function daemonFetchInternal(path, body) {
+  const daemonUrl = getDaemonUrl();
+  const token = process.env.VOLUTE_DAEMON_TOKEN;
+  const headers = {
+    "Content-Type": "application/json",
+    Origin: daemonUrl
+  };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  return fetch(`${daemonUrl}${path}`, { method: "POST", headers, body });
+}
+function accumulateEvent(content, event) {
+  if (event.type === "text") {
+    const last = content[content.length - 1];
+    if (last && last.type === "text") last.text += event.content;
+    else content.push({ type: "text", text: event.content });
+  } else if (event.type === "tool_use") {
+    content.push({ type: "tool_use", name: event.name, input: event.input });
+  } else if (event.type === "tool_result") {
+    content.push({
+      type: "tool_result",
+      output: event.output,
+      ...event.is_error ? { is_error: true } : {}
+    });
+  }
+}
+async function consumeAndPersist(res, conversationId, agentName) {
+  if (!res.body) {
+    console.warn(`[chat] no response body from ${agentName}`);
+    return [];
+  }
+  const assistantContent = [];
+  for await (const event of readNdjson(res.body)) {
+    accumulateEvent(assistantContent, event);
+    if (event.type === "done") break;
+  }
+  if (assistantContent.length === 0) return [];
+  try {
+    await addMessage(conversationId, "assistant", agentName, assistantContent);
+  } catch (err) {
+    console.error(`[chat] failed to persist conversation message from ${agentName}:`, err);
+  }
+  return assistantContent;
+}
 var app3 = new Hono3().post("/:name/chat", zValidator2("json", chatSchema), async (c) => {
   const name = c.req.param("name");
-  const [baseName, variantName] = name.split("@", 2);
+  const [baseName] = name.split("@", 2);
   const entry = findAgent(baseName);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
-  let port = entry.port;
-  if (variantName) {
-    const variant = findVariant(baseName, variantName);
-    if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
-    port = variant.port;
-  }
-  const { getAgentManager: getAgentManager2 } = await import("./agent-manager-AUCKMGPR.js");
+  const { getAgentManager: getAgentManager2 } = await import("./agent-manager-PXBKA2GK.js");
   if (!getAgentManager2().isRunning(name)) {
     return c.json({ error: "Agent is not running" }, 409);
   }
@@ -1125,18 +1490,34 @@ var app3 = new Hono3().post("/:name/chat", zValidator2("json", chatSchema), asyn
     return c.json({ error: "message or images required" }, 400);
   }
   const user = c.get("user");
+  const agentUser = await getOrCreateAgentUser(baseName);
+  const senderName = user.id === 0 && body.sender ? body.sender : user.username;
   let conversationId = body.conversationId;
   if (conversationId) {
-    const conv = await getConversationForUser(conversationId, user.id);
-    if (!conv) return c.json({ error: "Conversation not found" }, 404);
+    if (user.id !== 0 && !await isParticipantOrOwner(conversationId, user.id)) {
+      return c.json({ error: "Conversation not found" }, 404);
+    }
   } else {
     const title = body.message ? body.message.slice(0, 80) : "Image message";
-    const conv = await createConversation(baseName, "web", {
-      userId: user.id,
-      title
+    const participantIds = [];
+    if (user.id !== 0) {
+      participantIds.push(user.id);
+    } else if (body.sender) {
+      const senderAgent = findAgent(body.sender);
+      if (senderAgent) {
+        const senderAgentUser = await getOrCreateAgentUser(body.sender);
+        participantIds.push(senderAgentUser.id);
+      }
+    }
+    participantIds.push(agentUser.id);
+    const conv = await createConversation(baseName, "volute", {
+      userId: user.id !== 0 ? user.id : void 0,
+      title,
+      participantIds
     });
     conversationId = conv.id;
   }
+  const channel = `volute:${conversationId}`;
   const contentBlocks = [];
   if (body.message) {
     contentBlocks.push({ type: "text", text: body.message });
@@ -1146,73 +1527,87 @@ var app3 = new Hono3().post("/:name/chat", zValidator2("json", chatSchema), asyn
       contentBlocks.push({ type: "image", media_type: img.media_type, data: img.data });
     }
   }
-  await addMessage(conversationId, "user", user.username, contentBlocks);
-  const db2 = await getDb();
-  await db2.insert(agentMessages).values({
-    agent: baseName,
-    channel: "web",
-    role: "user",
-    sender: user.username,
-    content: body.message ?? "[image]"
-  });
-  const res = await fetch(`http://127.0.0.1:${port}/message`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      content: contentBlocks,
-      channel: "web",
-      sender: user.username
-    })
+  await addMessage(conversationId, "user", senderName, contentBlocks);
+  const participants = await getParticipants(conversationId);
+  const agentParticipants = participants.filter((p) => p.userType === "agent");
+  const participantNames = participants.map((p) => p.username);
+  const manager = getAgentManager2();
+  const runningAgents = agentParticipants.map((ap) => {
+    const agentKey = ap.username === baseName ? name : ap.username;
+    return manager.isRunning(agentKey) ? ap.username : null;
+  }).filter((n) => n !== null && n !== senderName);
+  if (runningAgents.length === 0) {
+    return c.json({ error: "No running agents in this conversation" }, 409);
+  }
+  const isDM = participants.length === 2;
+  const payload = JSON.stringify({
+    content: contentBlocks,
+    channel,
+    sender: senderName,
+    participants: participantNames,
+    participantCount: participants.length,
+    isDM
   });
-  if (!res.ok) {
-    return c.json({ error: `Agent responded with ${res.status}` }, res.status);
+  const responses = [];
+  for (const agentName of runningAgents) {
+    const targetName = agentName === baseName ? name : agentName;
+    try {
+      const res = await daemonFetchInternal(
+        `/api/agents/${encodeURIComponent(targetName)}/message`,
+        payload
+      );
+      if (res.ok && res.body) {
+        responses.push({ name: agentName, res });
+      } else {
+        const errorBody = await res.text().catch(() => "");
+        console.error(
+          `[chat] agent ${agentName} responded with ${res.status}: ${errorBody.slice(0, 500)}`
+        );
+      }
+    } catch (err) {
+      console.error(`[chat] agent ${agentName} unreachable via daemon:`, err);
+    }
   }
-  if (!res.body) {
-    return c.json({ error: "No response body from agent" }, 502);
+  if (responses.length === 0) {
+    return c.json({ error: "No agents reachable" }, 502);
   }
+  const primary = responses[0];
+  const secondary = responses.slice(1);
+  const secondaryPromises = secondary.map((s) => consumeAndPersist(s.res, conversationId, s.name));
   return streamSSE(c, async (stream2) => {
     await stream2.writeSSE({
-      data: JSON.stringify({ type: "meta", conversationId })
+      data: JSON.stringify({ type: "meta", conversationId, senderName: primary.name })
     });
     const assistantContent = [];
-    for await (const event of readNdjson(res.body)) {
-      await stream2.writeSSE({ data: JSON.stringify(event) });
-      if (event.type === "text") {
-        const last = assistantContent[assistantContent.length - 1];
-        if (last && last.type === "text") {
-          last.text += event.content;
-        } else {
-          assistantContent.push({ type: "text", text: event.content });
-        }
-      } else if (event.type === "tool_use") {
-        assistantContent.push({
-          type: "tool_use",
-          name: event.name,
-          input: event.input
-        });
-      } else if (event.type === "tool_result") {
-        assistantContent.push({
-          type: "tool_result",
-          output: event.output,
-          ...event.is_error ? { is_error: true } : {}
-        });
+    try {
+      for await (const event of readNdjson(primary.res.body)) {
+        await stream2.writeSSE({ data: JSON.stringify(event) });
+        accumulateEvent(assistantContent, event);
+        if (event.type === "done") break;
       }
-      if (event.type === "done") {
-        if (assistantContent.length > 0) {
-          await addMessage(conversationId, "assistant", baseName, assistantContent);
-          const textParts = assistantContent.filter((b) => b.type === "text").map((b) => b.text);
-          if (textParts.length > 0) {
-            await db2.insert(agentMessages).values({
-              agent: baseName,
-              channel: "web",
-              role: "assistant",
-              content: textParts.join("")
-            });
-          }
-        }
-        break;
+    } catch (err) {
+      console.error(`[chat] error streaming response from ${primary.name}:`, err);
+      await stream2.writeSSE({
+        data: JSON.stringify({ type: "error", message: "Stream interrupted" })
+      });
+    }
+    if (assistantContent.length > 0) {
+      try {
+        await addMessage(conversationId, "assistant", primary.name, assistantContent);
+      } catch (err) {
+        console.error(`[chat] failed to persist response from ${primary.name}:`, err);
+      }
+    }
+    const results = await Promise.allSettled(secondaryPromises);
+    for (let i = 0; i < results.length; i++) {
+      if (results[i].status === "rejected") {
+        console.error(
+          `[chat] secondary agent ${secondary[i].name} response failed:`,
+          results[i].reason
+        );
       }
     }
+    await stream2.writeSSE({ data: JSON.stringify({ type: "sync" }) });
   });
 });
 var chat_default = app3;
@@ -1243,13 +1638,24 @@ var app4 = new Hono4().get("/:name/connectors", (c) => {
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
+  const manager = getConnectorManager();
+  const envCheck = manager.checkConnectorEnv(type, dir);
+  if (envCheck) {
+    return c.json(
+      {
+        error: "missing_env",
+        missing: envCheck.missing,
+        connectorName: envCheck.connectorName
+      },
+      400
+    );
+  }
   const config = readVoluteConfig(dir) ?? {};
   const connectors = config.connectors ?? [];
   if (!connectors.includes(type)) {
     config.connectors = [...connectors, type];
     writeVoluteConfig(dir, config);
   }
-  const manager = getConnectorManager();
   try {
     await manager.startConnector(name, dir, entry.port, type);
     return c.json({ ok: true });
@@ -1278,19 +1684,79 @@ var app4 = new Hono4().get("/:name/connectors", (c) => {
 var connectors_default = app4;
 
 // src/web/routes/conversations.ts
+import { zValidator as zValidator3 } from "@hono/zod-validator";
 import { Hono as Hono5 } from "hono";
+import { z as z3 } from "zod";
+var createConvSchema = z3.object({
+  title: z3.string().optional(),
+  participantIds: z3.array(z3.number()).optional(),
+  participantNames: z3.array(z3.string()).optional()
+});
 var app5 = new Hono5().get("/:name/conversations", async (c) => {
   const name = c.req.param("name");
   const user = c.get("user");
-  const convs = await listConversations(name, { userId: user.id });
+  let lookupId = user.id;
+  if (user.id === 0) {
+    const agentUser = await getOrCreateAgentUser(name);
+    lookupId = agentUser.id;
+  }
+  const all = await listConversationsForUser(lookupId);
+  const convs = all.filter((c2) => c2.agent_name === name);
   return c.json(convs);
+}).post("/:name/conversations", zValidator3("json", createConvSchema), async (c) => {
+  const name = c.req.param("name");
+  const user = c.get("user");
+  const body = c.req.valid("json");
+  if (!body.participantIds?.length && !body.participantNames?.length) {
+    return c.json({ error: "participantIds or participantNames required" }, 400);
+  }
+  const agentUser = await getOrCreateAgentUser(name);
+  const participantSet = /* @__PURE__ */ new Set();
+  if (user.id !== 0) participantSet.add(user.id);
+  participantSet.add(agentUser.id);
+  for (const id of body.participantIds ?? []) participantSet.add(id);
+  if (body.participantNames) {
+    for (const pname of body.participantNames) {
+      const existing = await getUserByUsername(pname);
+      if (existing) {
+        participantSet.add(existing.id);
+        continue;
+      }
+      if (findAgent(pname)) {
+        const au = await getOrCreateAgentUser(pname);
+        participantSet.add(au.id);
+        continue;
+      }
+      return c.json({ error: `User not found: ${pname}` }, 400);
+    }
+  }
+  for (const id of participantSet) {
+    if (id === user.id || id === agentUser.id) continue;
+    const u = await getUser(id);
+    if (!u) return c.json({ error: `User ${id} not found` }, 400);
+  }
+  const conv = await createConversation(name, "volute", {
+    userId: user.id !== 0 ? user.id : void 0,
+    title: body.title,
+    participantIds: [...participantSet]
+  });
+  return c.json(conv, 201);
 }).get("/:name/conversations/:id/messages", async (c) => {
   const id = c.req.param("id");
   const user = c.get("user");
-  const conv = await getConversationForUser(id, user.id);
-  if (!conv) return c.json({ error: "Conversation not found" }, 404);
+  if (user.id !== 0 && !await isParticipantOrOwner(id, user.id)) {
+    return c.json({ error: "Conversation not found" }, 404);
+  }
   const msgs = await getMessages(id);
   return c.json(msgs);
+}).get("/:name/conversations/:id/participants", async (c) => {
+  const id = c.req.param("id");
+  const user = c.get("user");
+  if (!await isParticipantOrOwner(id, user.id)) {
+    return c.json({ error: "Conversation not found" }, 404);
+  }
+  const participants = await getParticipants(id);
+  return c.json(participants);
 }).delete("/:name/conversations/:id", async (c) => {
   const id = c.req.param("id");
   const user = c.get("user");
@@ -1301,21 +1767,21 @@ var app5 = new Hono5().get("/:name/conversations", async (c) => {
 var conversations_default = app5;
 
 // src/web/routes/files.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { readdir, readFile, writeFile } from "fs/promises";
-import { resolve as resolve5 } from "path";
-import { zValidator as zValidator3 } from "@hono/zod-validator";
+import { resolve as resolve7 } from "path";
+import { zValidator as zValidator4 } from "@hono/zod-validator";
 import { Hono as Hono6 } from "hono";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var ALLOWED_FILES = /* @__PURE__ */ new Set(["SOUL.md", "MEMORY.md", "CLAUDE.md", "VOLUTE.md"]);
-var saveFileSchema = z3.object({ content: z3.string() });
+var saveFileSchema = z4.object({ content: z4.string() });
 var app6 = new Hono6().get("/:name/files", async (c) => {
   const name = c.req.param("name");
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
-  const homeDir = resolve5(dir, "home");
-  if (!existsSync4(homeDir)) return c.json({ error: "Home directory missing" }, 404);
+  const homeDir = resolve7(dir, "home");
+  if (!existsSync5(homeDir)) return c.json({ error: "Home directory missing" }, 404);
   const allFiles = await readdir(homeDir);
   const files = allFiles.filter((f) => f.endsWith(".md") && ALLOWED_FILES.has(f));
   return c.json(files);
@@ -1328,13 +1794,13 @@ var app6 = new Hono6().get("/:name/files", async (c) => {
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
-  const filePath = resolve5(dir, "home", filename);
-  if (!existsSync4(filePath)) {
+  const filePath = resolve7(dir, "home", filename);
+  if (!existsSync5(filePath)) {
     return c.json({ error: "File not found" }, 404);
   }
   const content = await readFile(filePath, "utf-8");
   return c.json({ filename, content });
-}).put("/:name/files/:filename", zValidator3("json", saveFileSchema), async (c) => {
+}).put("/:name/files/:filename", zValidator4("json", saveFileSchema), async (c) => {
   const name = c.req.param("name");
   const filename = c.req.param("filename");
   if (!ALLOWED_FILES.has(filename)) {
@@ -1343,7 +1809,7 @@ var app6 = new Hono6().get("/:name/files", async (c) => {
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
-  const filePath = resolve5(dir, "home", filename);
+  const filePath = resolve7(dir, "home", filename);
   const { content } = c.req.valid("json");
   await writeFile(filePath, content);
   return c.json({ ok: true });
@@ -1352,8 +1818,8 @@ var files_default = app6;
 
 // src/web/routes/logs.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync5 } from "fs";
-import { resolve as resolve6 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { resolve as resolve8 } from "path";
 import { Hono as Hono7 } from "hono";
 import { streamSSE as streamSSE2 } from "hono/streaming";
 var app7 = new Hono7().get("/:name/logs", async (c) => {
@@ -1361,8 +1827,8 @@ var app7 = new Hono7().get("/:name/logs", async (c) => {
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
-  const logFile = resolve6(dir, ".volute", "logs", "agent.log");
-  if (!existsSync5(logFile)) {
+  const logFile = resolve8(dir, ".volute", "logs", "agent.log");
+  if (!existsSync6(logFile)) {
     return c.json({ error: "No log file found" }, 404);
   }
   return streamSSE2(c, async (stream2) => {
@@ -1380,9 +1846,9 @@ var app7 = new Hono7().get("/:name/logs", async (c) => {
     stream2.onAbort(() => {
       tail.kill();
     });
-    await new Promise((resolve9) => {
-      tail.on("exit", resolve9);
-      stream2.onAbort(resolve9);
+    await new Promise((resolve11) => {
+      tail.on("exit", resolve11);
+      stream2.onAbort(resolve11);
     });
   });
 });
@@ -1484,19 +1950,99 @@ var app9 = new Hono9().get("/logs", async (c) => {
       stream2.writeSSE({ data: JSON.stringify(entry) }).catch(() => {
       });
     });
-    await new Promise((resolve9) => {
+    await new Promise((resolve11) => {
       stream2.onAbort(() => {
         unsubscribe();
-        resolve9();
+        resolve11();
       });
     });
   });
 });
 var system_default = app9;
 
-// src/web/routes/variants.ts
+// src/web/routes/update.ts
+import { spawn as spawn3 } from "child_process";
 import { Hono as Hono10 } from "hono";
-var app10 = new Hono10().get("/:name/variants", async (c) => {
+var bin;
+var app10 = new Hono10().get("/update", async (c) => {
+  const result = await checkForUpdate();
+  return c.json(result);
+}).post("/update", requireAdmin, async (c) => {
+  bin ??= resolveVoluteBin();
+  const child = spawn3(bin, ["update"], {
+    stdio: "ignore",
+    detached: true
+  });
+  child.on("error", (err) => {
+    logger_default.error("Update process error", { error: err.message });
+  });
+  child.unref();
+  return c.json({ ok: true, message: "Updating..." });
+});
+var update_default = app10;
+
+// src/web/routes/user-conversations.ts
+import { zValidator as zValidator5 } from "@hono/zod-validator";
+import { Hono as Hono11 } from "hono";
+import { z as z5 } from "zod";
+var createSchema = z5.object({
+  title: z5.string().optional(),
+  participantNames: z5.array(z5.string()).min(1)
+});
+var app11 = new Hono11().use("*", authMiddleware).get("/", async (c) => {
+  const user = c.get("user");
+  const convs = await listConversationsWithParticipants(user.id);
+  return c.json(convs);
+}).get("/:id/messages", async (c) => {
+  const id = c.req.param("id");
+  const user = c.get("user");
+  if (user.id !== 0 && !await isParticipantOrOwner(id, user.id)) {
+    return c.json({ error: "Conversation not found" }, 404);
+  }
+  const msgs = await getMessages(id);
+  return c.json(msgs);
+}).post("/", zValidator5("json", createSchema), async (c) => {
+  const user = c.get("user");
+  const body = c.req.valid("json");
+  const participantIds = /* @__PURE__ */ new Set();
+  if (user.id !== 0) participantIds.add(user.id);
+  let firstAgentName;
+  for (const name of body.participantNames) {
+    const existing = await getUserByUsername(name);
+    if (existing) {
+      participantIds.add(existing.id);
+      if (!firstAgentName && existing.user_type === "agent") firstAgentName = name;
+      continue;
+    }
+    if (findAgent(name)) {
+      const au = await getOrCreateAgentUser(name);
+      participantIds.add(au.id);
+      if (!firstAgentName) firstAgentName = name;
+      continue;
+    }
+    return c.json({ error: `User not found: ${name}` }, 400);
+  }
+  if (!firstAgentName) {
+    return c.json({ error: "At least one agent participant is required" }, 400);
+  }
+  const conv = await createConversation(firstAgentName, "volute", {
+    userId: user.id !== 0 ? user.id : void 0,
+    title: body.title,
+    participantIds: [...participantIds]
+  });
+  return c.json(conv, 201);
+}).delete("/:id", async (c) => {
+  const id = c.req.param("id");
+  const user = c.get("user");
+  const deleted = await deleteConversationForUser(id, user.id);
+  if (!deleted) return c.json({ error: "Conversation not found" }, 404);
+  return c.json({ ok: true });
+});
+var user_conversations_default = app11;
+
+// src/web/routes/variants.ts
+import { Hono as Hono12 } from "hono";
+var app12 = new Hono12().get("/:name/variants", async (c) => {
   const name = c.req.param("name");
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
@@ -1510,11 +2056,11 @@ var app10 = new Hono10().get("/:name/variants", async (c) => {
   );
   return c.json(results);
 });
-var variants_default = app10;
+var variants_default = app12;
 
 // src/web/app.ts
-var app11 = new Hono11();
-app11.onError((err, c) => {
+var app13 = new Hono13();
+app13.onError((err, c) => {
   if (err instanceof HTTPException) {
     return err.getResponse();
   }
@@ -1525,10 +2071,10 @@ app11.onError((err, c) => {
   });
   return c.json({ error: "Internal server error" }, 500);
 });
-app11.notFound((c) => {
+app13.notFound((c) => {
   return c.json({ error: "Not found" }, 404);
 });
-app11.use("*", async (c, next) => {
+app13.use("*", async (c, next) => {
   const start = Date.now();
   await next();
   const duration = Date.now() - start;
@@ -1539,15 +2085,28 @@ app11.use("*", async (c, next) => {
     duration
   });
 });
-app11.get("/api/health", (c) => {
-  return c.json({ ok: true, version: "0.1.0" });
+app13.get("/api/health", (c) => {
+  let version = "unknown";
+  let cached = null;
+  try {
+    version = getCurrentVersion();
+    cached = checkForUpdateCached();
+  } catch (err) {
+    logger_default.error("Health check error", { error: err.message });
+  }
+  return c.json({
+    ok: true,
+    version,
+    ...cached?.updateAvailable ? { updateAvailable: true, latest: cached.latest } : {}
+  });
 });
-app11.use("/api/*", bodyLimit({ maxSize: 10 * 1024 * 1024 }));
-app11.use("/api/*", csrf());
-app11.use("/api/agents/*", authMiddleware);
-app11.use("/api/system/*", authMiddleware);
-var routes = app11.route("/api/auth", auth_default).route("/api/system", system_default).route("/api/agents", agents_default).route("/api/agents", chat_default).route("/api/agents", connectors_default).route("/api/agents", schedules_default).route("/api/agents", logs_default).route("/api/agents", variants_default).route("/api/agents", files_default).route("/api/agents", conversations_default);
-var app_default = app11;
+app13.use("/api/*", bodyLimit({ maxSize: 10 * 1024 * 1024 }));
+app13.use("/api/*", csrf());
+app13.use("/api/agents/*", authMiddleware);
+app13.use("/api/conversations/*", authMiddleware);
+app13.use("/api/system/*", authMiddleware);
+var routes = app13.route("/api/auth", auth_default).route("/api/system", system_default).route("/api/system", update_default).route("/api/agents", agents_default).route("/api/agents", chat_default).route("/api/agents", connectors_default).route("/api/agents", schedules_default).route("/api/agents", logs_default).route("/api/agents", variants_default).route("/api/agents", files_default).route("/api/agents", conversations_default).route("/api/conversations", user_conversations_default);
+var app_default = app13;
 
 // src/web/server.ts
 var MIME_TYPES = {
@@ -1566,8 +2125,8 @@ async function startServer({
   let assetsDir = "";
   let searchDir = dirname3(new URL(import.meta.url).pathname);
   for (let i = 0; i < 5; i++) {
-    const candidate = resolve7(searchDir, "dist", "web-assets");
-    if (existsSync6(candidate)) {
+    const candidate = resolve9(searchDir, "dist", "web-assets");
+    if (existsSync7(candidate)) {
       assetsDir = candidate;
       break;
     }
@@ -1576,7 +2135,8 @@ async function startServer({
   if (assetsDir) {
     app_default.get("*", async (c) => {
       const urlPath = new URL(c.req.url).pathname;
-      const filePath = resolve7(assetsDir, urlPath.slice(1));
+      if (urlPath.startsWith("/api/")) return c.notFound();
+      const filePath = resolve9(assetsDir, urlPath.slice(1));
       if (!filePath.startsWith(assetsDir)) return c.text("Forbidden", 403);
       const s = await stat(filePath).catch(() => null);
       if (s?.isFile()) {
@@ -1585,7 +2145,7 @@ async function startServer({
         const body = await readFile2(filePath);
         return c.body(body, 200, { "Content-Type": mime });
       }
-      const indexPath = resolve7(assetsDir, "index.html");
+      const indexPath = resolve9(assetsDir, "index.html");
       const indexStat = await stat(indexPath).catch(() => null);
       if (indexStat?.isFile()) {
         const body = await readFile2(indexPath, "utf-8");
@@ -1595,10 +2155,10 @@ async function startServer({
     });
   }
   const server = serve({ fetch: app_default.fetch, port, hostname });
-  await new Promise((resolve9, reject) => {
+  await new Promise((resolve11, reject) => {
     server.on("listening", () => {
       logger_default.info("Volute UI running", { hostname, port });
-      resolve9();
+      resolve11();
     });
     server.on("error", (err) => {
       reject(err);
@@ -1608,12 +2168,24 @@ async function startServer({
 }
 
 // src/daemon.ts
+if (!process.env.VOLUTE_HOME) {
+  process.env.VOLUTE_HOME = resolve10(homedir(), ".volute");
+}
 async function startDaemon(opts) {
   const { port, hostname } = opts;
   const myPid = String(process.pid);
   const home = voluteHome();
-  const DAEMON_PID_PATH = resolve8(home, "daemon.pid");
-  const DAEMON_JSON_PATH = resolve8(home, "daemon.json");
+  if (!opts.foreground) {
+    const log2 = new RotatingLog(resolve10(home, "daemon.log"));
+    const write2 = (...args) => log2.write(`${format(...args)}
+`);
+    console.log = write2;
+    console.error = write2;
+    console.warn = write2;
+    console.info = write2;
+  }
+  const DAEMON_PID_PATH = resolve10(home, "daemon.pid");
+  const DAEMON_JSON_PATH = resolve10(home, "daemon.json");
   mkdirSync2(home, { recursive: true });
   const token = process.env.VOLUTE_DAEMON_TOKEN || randomBytes(32).toString("hex");
   process.env.VOLUTE_DAEMON_TOKEN = token;
@@ -1666,13 +2238,13 @@ async function startDaemon(opts) {
   console.error(`[daemon] running on ${hostname}:${port}, pid ${myPid}`);
   function cleanup() {
     try {
-      if (readFileSync3(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
+      if (readFileSync5(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
         unlinkSync2(DAEMON_PID_PATH);
       }
     } catch {
     }
     try {
-      const data = JSON.parse(readFileSync3(DAEMON_JSON_PATH, "utf-8"));
+      const data = JSON.parse(readFileSync5(DAEMON_JSON_PATH, "utf-8"));
       if (data.token === token) {
         unlinkSync2(DAEMON_JSON_PATH);
       }