volute 0.6.0 → 0.8.0

package/dist/daemon.js

@@ -6,32 +6,51 @@ import {
   initAgentManager,
   loadJsonMap,
   saveJsonMap
-} from "./chunk-G6ZNGLUX.js";
+} from "./chunk-W6TMWYU3.js";
 import {
   checkForUpdate,
   checkForUpdateCached,
   getCurrentVersion
-} from "./chunk-AOKAQGO4.js";
-import {
-  collectPart
-} from "./chunk-B3R6L2GW.js";
+} from "./chunk-RT6Y7AR3.js";
 import {
   CHANNELS
-} from "./chunk-ZZOOTYXK.js";
+} from "./chunk-LIPPXNIE.js";
+import {
+  agentMessages,
+  approveUser,
+  conversationParticipants,
+  conversations,
+  createUser,
+  deleteAgentUser,
+  getDb,
+  getOrCreateAgentUser,
+  getUser,
+  getUserByUsername,
+  listPendingUsers,
+  listUsers,
+  listUsersByType,
+  messages,
+  sessions,
+  users,
+  verifyUser
+} from "./chunk-ECPQXRLB.js";
 import {
   readVoluteConfig,
   writeVoluteConfig
 } from "./chunk-NETNFBA5.js";
 import {
   loadMergedEnv
-} from "./chunk-H7AMDUIA.js";
-import "./chunk-BX7KI4S3.js";
+} from "./chunk-QF22MYDJ.js";
+import {
+  slugify,
+  writeChannelEntry
+} from "./chunk-N6MLQ26B.js";
 import {
   applyIsolation
-} from "./chunk-W76KWE23.js";
+} from "./chunk-IQXBMFZG.js";
 import {
   resolveVoluteBin
-} from "./chunk-5SKQ6J7T.js";
+} from "./chunk-5C5JWR2L.js";
 import {
   agentDir,
   checkHealth,
@@ -45,15 +64,15 @@ import {
   removeAllVariants,
   setAgentRunning,
   setVariantRunning,
+  stateDir,
+  validateBranchName,
   voluteHome
-} from "./chunk-UWHWAPGO.js";
-import {
-  __export
-} from "./chunk-K3NQKI34.js";
+} from "./chunk-DP2DX4WV.js";
+import "./chunk-K3NQKI34.js";
 
 // src/daemon.ts
 import { randomBytes } from "crypto";
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { mkdirSync as mkdirSync3, 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";
@@ -166,13 +185,13 @@ var ConnectorManager = class {
       }
     }
   }
-  checkConnectorEnv(type, agentDir2) {
+  checkConnectorEnv(type, agentName, 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 env = loadMergedEnv(agentName);
     const missing = checkMissingEnvVars(def, env);
     if (missing.length === 0) return null;
     return {
@@ -200,7 +219,7 @@ var ConnectorManager = class {
       });
       this.connectors.get(agentName)?.delete(type);
     }
-    this.killOrphanConnector(agentDir2, type);
+    this.killOrphanConnector(agentName, type);
     const agentConnector = resolve2(agentDir2, "connectors", type, "index.ts");
     const userConnector = resolve2(voluteHome(), "connectors", type, "index.ts");
     const builtinConnector = this.resolveBuiltinConnector(type);
@@ -218,10 +237,10 @@ var ConnectorManager = class {
     } else {
       throw new Error(`No connector code found for type: ${type}`);
     }
-    const logsDir = resolve2(agentDir2, ".volute", "logs");
+    const logsDir = resolve2(stateDir(agentName), "logs");
     mkdirSync(logsDir, { recursive: true });
     const logStream = new RotatingLog(resolve2(logsDir, `${type}.log`));
-    const agentEnv = loadMergedEnv(agentDir2);
+    const agentEnv = loadMergedEnv(agentName);
     const prefix = `${type.toUpperCase()}_`;
     const connectorEnv = Object.fromEntries(
       Object.entries(agentEnv).filter(([k]) => k.startsWith(prefix))
@@ -249,7 +268,7 @@ var ConnectorManager = class {
       lastStderr = chunk.toString().trim();
     });
     if (child.pid) {
-      this.saveConnectorPid(agentDir2, type, child.pid);
+      this.saveConnectorPid(agentName, type, child.pid);
     }
     if (!this.connectors.has(agentName)) {
       this.connectors.set(agentName, /* @__PURE__ */ new Map());
@@ -313,8 +332,9 @@ var ConnectorManager = class {
     this.stopping.delete(stopKey);
     this.restartAttempts.delete(stopKey);
     try {
-      this.removeConnectorPid(agentDir(agentName), type);
-    } catch {
+      this.removeConnectorPid(agentName, type);
+    } catch (err) {
+      console.error(`[daemon] failed to remove PID file for ${type}/${agentName}:`, err);
     }
     console.error(`[daemon] stopped connector ${type} for ${agentName}`);
   }
@@ -338,22 +358,22 @@ var ConnectorManager = class {
       running: !tracked.child.killed
     }));
   }
-  connectorPidPath(agentDir2, type) {
-    return resolve2(agentDir2, ".volute", "connectors", `${type}.pid`);
+  connectorPidPath(agentName, type) {
+    return resolve2(stateDir(agentName), "connectors", `${type}.pid`);
   }
-  saveConnectorPid(agentDir2, type, pid) {
-    const pidPath = this.connectorPidPath(agentDir2, type);
+  saveConnectorPid(agentName, type, pid) {
+    const pidPath = this.connectorPidPath(agentName, type);
     mkdirSync(dirname(pidPath), { recursive: true });
     writeFileSync(pidPath, String(pid));
   }
-  removeConnectorPid(agentDir2, type) {
+  removeConnectorPid(agentName, type) {
     try {
-      unlinkSync(this.connectorPidPath(agentDir2, type));
+      unlinkSync(this.connectorPidPath(agentName, type));
     } catch {
     }
   }
-  killOrphanConnector(agentDir2, type) {
-    const pidPath = this.connectorPidPath(agentDir2, type);
+  killOrphanConnector(agentName, type) {
+    const pidPath = this.connectorPidPath(agentName, type);
     if (!existsSync2(pidPath)) return;
     try {
       const pid = parseInt(readFileSync2(pidPath, "utf-8").trim(), 10);
@@ -386,8 +406,37 @@ function getConnectorManager() {
   return instance;
 }
 
-// src/lib/scheduler.ts
+// src/lib/migrate-state.ts
+import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync } from "fs";
 import { resolve as resolve3 } from "path";
+function migrateAgentState(name) {
+  const src = resolve3(agentDir(name), ".volute");
+  if (!existsSync3(src)) return;
+  const dest = stateDir(name);
+  mkdirSync2(dest, { recursive: true });
+  for (const file of ["env.json", "channels.json"]) {
+    const srcPath = resolve3(src, file);
+    const destPath = resolve3(dest, file);
+    if (existsSync3(srcPath) && !existsSync3(destPath)) {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+  const srcLogs = resolve3(src, "logs");
+  const destLogs = resolve3(dest, "logs");
+  if (existsSync3(srcLogs) && !existsSync3(destLogs)) {
+    mkdirSync2(destLogs, { recursive: true });
+    for (const file of readdirSync(srcLogs)) {
+      try {
+        copyFileSync(resolve3(srcLogs, file), resolve3(destLogs, file));
+      } catch (err) {
+        console.error(`[migrate] failed to copy log ${file} for ${name}:`, err);
+      }
+    }
+  }
+}
+
+// src/lib/scheduler.ts
+import { resolve as resolve4 } from "path";
 import { CronExpressionParser } from "cron-parser";
 var Scheduler = class {
   schedules = /* @__PURE__ */ new Map();
@@ -397,7 +446,7 @@ var Scheduler = class {
   daemonPort = null;
   daemonToken = null;
   get statePath() {
-    return resolve3(voluteHome(), "scheduler-state.json");
+    return resolve4(voluteHome(), "scheduler-state.json");
   }
   start(daemonPort, daemonToken) {
     this.daemonPort = daemonPort ?? null;
@@ -504,18 +553,8 @@ 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 {
-      }
+      await res.text().catch(() => {
+      });
     } catch (err) {
       console.error(`[scheduler] failed to fire "${schedule.id}" for ${agentName}:`, err);
     } finally {
@@ -676,18 +715,8 @@ ${summary}`
           `[token-budget] replayed ${messages2.length} queued message(s) for ${agentName}`
         );
       }
-      try {
-        const reader = res.body?.getReader();
-        if (reader) {
-          try {
-            while (!(await reader.read()).done) {
-            }
-          } finally {
-            reader.releaseLock();
-          }
-        }
-      } catch {
-      }
+      await res.text().catch(() => {
+      });
     } catch (err) {
       console.error(`[token-budget] failed to replay for ${agentName}:`, err);
       const state = this.budgets.get(agentName);
@@ -705,245 +734,9 @@ function getTokenBudget() {
 
 // src/web/middleware/auth.ts
 import { timingSafeEqual } from "crypto";
-import { eq as eq2, lt } from "drizzle-orm";
+import { eq, lt } from "drizzle-orm";
 import { getCookie } from "hono/cookie";
 import { createMiddleware } from "hono/factory";
-
-// src/lib/auth.ts
-import { compareSync, hashSync } from "bcryptjs";
-import { and, count, eq } from "drizzle-orm";
-
-// src/lib/db.ts
-import { chmodSync, existsSync as 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";
-
-// src/lib/schema.ts
-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, uniqueIndex } from "drizzle-orm/sqlite-core";
-var users = sqliteTable("users", {
-  id: integer("id").primaryKey({ autoIncrement: true }),
-  username: text("username").unique().notNull(),
-  password_hash: text("password_hash").notNull(),
-  role: text("role").notNull().default("pending"),
-  user_type: text("user_type").notNull().default("human"),
-  created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
-});
-var conversations = sqliteTable(
-  "conversations",
-  {
-    id: text("id").primaryKey(),
-    agent_name: text("agent_name").notNull(),
-    channel: text("channel").notNull(),
-    user_id: integer("user_id").references(() => users.id),
-    title: text("title"),
-    created_at: text("created_at").notNull().default(sql`(datetime('now'))`),
-    updated_at: text("updated_at").notNull().default(sql`(datetime('now'))`)
-  },
-  (table) => [
-    index("idx_conversations_agent_name").on(table.agent_name),
-    index("idx_conversations_user_id").on(table.user_id),
-    index("idx_conversations_updated_at").on(table.updated_at)
-  ]
-);
-var agentMessages = sqliteTable(
-  "agent_messages",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    agent: text("agent").notNull(),
-    channel: text("channel").notNull(),
-    role: text("role").notNull(),
-    sender: text("sender"),
-    content: text("content").notNull(),
-    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
-  },
-  (table) => [
-    index("idx_agent_messages_agent").on(table.agent),
-    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(),
-  createdAt: integer("created_at").notNull()
-});
-var messages = sqliteTable(
-  "messages",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    conversation_id: text("conversation_id").notNull().references(() => conversations.id, { onDelete: "cascade" }),
-    role: text("role").notNull(),
-    sender_name: text("sender_name"),
-    content: text("content").notNull(),
-    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
-  },
-  (table) => [index("idx_messages_conversation_id").on(table.conversation_id)]
-);
-
-// src/lib/db.ts
-var __dirname = dirname2(fileURLToPath(import.meta.url));
-var migrationsFolder = 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 || resolve4(voluteHome(), "volute.db");
-  db = drizzle({ connection: { url: `file:${dbPath}` }, schema: schema_exports });
-  await migrate(db, { migrationsFolder });
-  try {
-    chmodSync(dbPath, 384);
-  } catch (err) {
-    console.error(
-      `[volute] WARNING: Failed to restrict database file permissions on ${dbPath}:`,
-      err
-    );
-  }
-  return db;
-}
-
-// src/lib/auth.ts
-async function createUser(username, password) {
-  const db2 = await getDb();
-  const hash = hashSync(password, 10);
-  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;
-}
-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;
-}
-async function getUser(id) {
-  const db2 = await getDb();
-  const row = 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(eq(users.id, id)).get();
-  return row ?? null;
-}
-async function getUserByUsername(username) {
-  const db2 = await getDb();
-  const row = 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(eq(users.username, username)).get();
-  return row ?? null;
-}
-async function listUsers() {
-  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).orderBy(users.created_at).all();
-}
-async function listPendingUsers() {
-  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.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")));
-}
-
-// src/web/middleware/auth.ts
 function isValidDaemonToken(token) {
   const expected = process.env.VOLUTE_DAEMON_TOKEN;
   if (!expected || token.length !== expected.length) return false;
@@ -951,29 +744,29 @@ function isValidDaemonToken(token) {
 }
 var SESSION_MAX_AGE = 864e5;
 async function createSession(userId) {
-  const db2 = await getDb();
+  const db = await getDb();
   const sessionId = crypto.randomUUID();
-  await db2.insert(sessions).values({ id: sessionId, userId, createdAt: Date.now() });
+  await db.insert(sessions).values({ id: sessionId, userId, createdAt: Date.now() });
   return sessionId;
 }
 async function deleteSession(sessionId) {
-  const db2 = await getDb();
-  await db2.delete(sessions).where(eq2(sessions.id, sessionId));
+  const db = await getDb();
+  await db.delete(sessions).where(eq(sessions.id, sessionId));
 }
 async function getSessionUserId(sessionId) {
-  const db2 = await getDb();
-  const row = await db2.select().from(sessions).where(eq2(sessions.id, sessionId)).get();
+  const db = await getDb();
+  const row = await db.select().from(sessions).where(eq(sessions.id, sessionId)).get();
   if (!row) return void 0;
   if (Date.now() - row.createdAt > SESSION_MAX_AGE) {
-    await db2.delete(sessions).where(eq2(sessions.id, sessionId));
+    await db.delete(sessions).where(eq(sessions.id, sessionId));
     return void 0;
   }
   return row.userId;
 }
 async function cleanExpiredSessions() {
-  const db2 = await getDb();
+  const db = await getDb();
   const cutoff = Date.now() - SESSION_MAX_AGE;
-  await db2.delete(sessions).where(lt(sessions.createdAt, cutoff));
+  await db.delete(sessions).where(lt(sessions.createdAt, cutoff));
 }
 var requireAdmin = createMiddleware(async (c, next) => {
   const user = c.get("user");
@@ -1006,7 +799,7 @@ var authMiddleware = createMiddleware(async (c, next) => {
 // src/web/server.ts
 import { existsSync as existsSync7 } from "fs";
 import { readFile as readFile2, stat } from "fs/promises";
-import { dirname as dirname3, extname, resolve as resolve9 } from "path";
+import { dirname as dirname2, extname, resolve as resolve9 } from "path";
 import { serve } from "@hono/node-server";
 
 // src/lib/log-buffer.ts
@@ -1060,50 +853,12 @@ import { csrf } from "hono/csrf";
 import { HTTPException } from "hono/http-exception";
 
 // src/web/routes/agents.ts
+import { execFile } from "child_process";
 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 { promisify } from "util";
+import { and, desc, eq as eq2 } from "drizzle-orm";
 import { Hono } from "hono";
-import { stream } from "hono/streaming";
-
-// 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/lib/typing.ts
 var DEFAULT_TTL_MS = 1e4;
@@ -1173,11 +928,38 @@ function getTypingMap() {
 }
 
 // src/web/routes/agents.ts
+var execFileAsync = promisify(execFile);
+async function startAgentFull(name, baseName, variantName) {
+  await getAgentManager().startAgent(name);
+  if (variantName) return;
+  const dir = agentDir(baseName);
+  const entry = findAgent(baseName);
+  await getConnectorManager().startConnectors(baseName, dir, entry.port, getDaemonPort());
+  getScheduler().loadSchedules(baseName);
+  const config = readVoluteConfig(dir);
+  if (config?.tokenBudget) {
+    getTokenBudget().setBudget(
+      baseName,
+      config.tokenBudget,
+      config.tokenBudgetPeriodMinutes ?? DEFAULT_BUDGET_PERIOD_MINUTES
+    );
+  }
+}
+function extractTextContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter((p) => p.type === "text" && p.text).map((p) => p.text).join("\n");
+  }
+  return JSON.stringify(content);
+}
 function getDaemonPort() {
   try {
     const data = JSON.parse(readFileSync3(resolve5(voluteHome(), "daemon.json"), "utf-8"));
     return data.port;
-  } catch {
+  } catch (err) {
+    if (err?.code !== "ENOENT") {
+      console.error("[daemon] failed to read daemon.json:", err);
+    }
     return void 0;
   }
 }
@@ -1252,25 +1034,11 @@ var app = new Hono().get("/", async (c) => {
     const dir = agentDir(baseName);
     if (!existsSync4(dir)) return c.json({ error: "Agent directory missing" }, 404);
   }
-  const manager = getAgentManager();
-  if (manager.isRunning(name)) {
+  if (getAgentManager().isRunning(name)) {
     return c.json({ error: "Agent already running" }, 409);
   }
   try {
-    await manager.startAgent(name);
-    if (!variantName) {
-      const dir = agentDir(baseName);
-      await getConnectorManager().startConnectors(baseName, dir, entry.port, getDaemonPort());
-      getScheduler().loadSchedules(baseName);
-      const config = readVoluteConfig(dir);
-      if (config?.tokenBudget) {
-        getTokenBudget().setBudget(
-          baseName,
-          config.tokenBudget,
-          config.tokenBudgetPeriodMinutes ?? DEFAULT_BUDGET_PERIOD_MINUTES
-        );
-      }
-    }
+    await startAgentFull(name, baseName, variantName);
     return c.json({ ok: true });
   } catch (err) {
     return c.json({ error: err instanceof Error ? err.message : "Failed to start agent" }, 500);
@@ -1287,30 +1055,52 @@ var app = new Hono().get("/", async (c) => {
     const dir = agentDir(baseName);
     if (!existsSync4(dir)) return c.json({ error: "Agent directory missing" }, 404);
   }
+  let context;
+  const contentType = c.req.header("content-type");
+  if (contentType?.includes("application/json")) {
+    try {
+      const body = await c.req.json();
+      if (body?.context) context = body.context;
+    } catch (err) {
+      console.error(`[daemon] failed to parse restart context for ${name}:`, err);
+    }
+  }
   const manager = getAgentManager();
-  const connectorManager = getConnectorManager();
   try {
     if (manager.isRunning(name)) {
       if (!variantName) {
-        await connectorManager.stopConnectors(baseName);
+        await getConnectorManager().stopConnectors(baseName);
         getTokenBudget().removeBudget(baseName);
       }
       await manager.stopAgent(name);
     }
-    await manager.startAgent(name);
-    if (!variantName) {
-      const dir = agentDir(baseName);
-      await connectorManager.startConnectors(baseName, dir, entry.port, getDaemonPort());
-      getScheduler().loadSchedules(baseName);
-      const config = readVoluteConfig(dir);
-      if (config?.tokenBudget) {
-        getTokenBudget().setBudget(
-          baseName,
-          config.tokenBudget,
-          config.tokenBudgetPeriodMinutes ?? DEFAULT_BUDGET_PERIOD_MINUTES
-        );
+    if (context?.type === "merge" && context.name && !variantName) {
+      const mergeVariantName = String(context.name);
+      const branchErr = validateBranchName(mergeVariantName);
+      if (branchErr) {
+        return c.json({ error: `Invalid variant name: ${branchErr}` }, 400);
       }
+      console.error(`[daemon] merging variant for ${baseName}: ${mergeVariantName}`);
+      const mergeArgs = [
+        "variant",
+        "merge",
+        mergeVariantName,
+        "--agent",
+        baseName,
+        "--skip-verify"
+      ];
+      if (context.summary) mergeArgs.push("--summary", String(context.summary));
+      if (context.justification) mergeArgs.push("--justification", String(context.justification));
+      if (context.memory) mergeArgs.push("--memory", String(context.memory));
+      await execFileAsync("volute", mergeArgs, {
+        cwd: agentDir(baseName),
+        env: { ...process.env, VOLUTE_SUPERVISOR: "1" }
+      });
+    }
+    if (context) {
+      manager.setPendingContext(name, context);
     }
+    await startAgentFull(name, baseName, variantName);
     return c.json({ ok: true });
   } catch (err) {
     return c.json({ error: err instanceof Error ? err.message : "Failed to restart agent" }, 500);
@@ -1353,6 +1143,11 @@ var app = new Hono().get("/", async (c) => {
   }
   removeAllVariants(name);
   removeAgent(name);
+  await deleteAgentUser(name);
+  const state = stateDir(name);
+  if (existsSync4(state)) {
+    rmSync(state, { recursive: true, force: true });
+  }
   if (force && existsSync4(dir)) {
     rmSync(dir, { recursive: true, force: true });
   }
@@ -1379,23 +1174,15 @@ var app = new Hono().get("/", async (c) => {
     console.error(`[daemon] failed to parse message body for ${baseName}:`, err);
   }
   const channel = parsed?.channel ?? "unknown";
-  const db2 = await getDb();
+  const db = await getDb();
   if (parsed) {
     try {
-      const sender = parsed.sender ?? null;
-      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({
+      const sender2 = parsed.sender ?? null;
+      const content = extractTextContent(parsed.content);
+      await db.insert(agentMessages).values({
         agent: baseName,
         channel,
-        role: "user",
-        sender,
+        sender: sender2,
         content
       });
     } catch (err) {
@@ -1405,33 +1192,17 @@ var app = new Hono().get("/", async (c) => {
   const budget = getTokenBudget();
   const budgetStatus = budget.checkBudget(baseName);
   if (budgetStatus === "exceeded") {
-    let textContent = "";
-    if (parsed) {
-      if (typeof parsed.content === "string") {
-        textContent = parsed.content;
-      } else if (Array.isArray(parsed.content)) {
-        textContent = parsed.content.filter((p) => p.type === "text" && p.text).map((p) => p.text).join("\n");
-      }
-    }
+    const textContent = parsed ? extractTextContent(parsed.content) : "";
     budget.enqueue(baseName, {
       channel,
       sender: parsed?.sender ?? null,
       textContent
     });
-    c.header("Content-Type", "application/x-ndjson");
-    const encoder2 = new TextEncoder();
-    return stream(c, async (s) => {
-      await s.write(
-        encoder2.encode(
-          `${JSON.stringify({ type: "text", content: "[Token budget exceeded \u2014 message queued for next period]" })}
-`
-        )
-      );
-      await s.write(encoder2.encode(`${JSON.stringify({ type: "done" })}
-`));
-    });
+    return c.json({ error: "Token budget exceeded \u2014 message queued for next period" }, 429);
   }
   const typingMap = getTypingMap();
+  const sender = parsed?.sender ?? "";
+  if (sender) typingMap.delete(channel, sender);
   const currentlyTyping = typingMap.get(channel).filter((s) => s !== baseName);
   let forwardBody = body;
   if (parsed && currentlyTyping.length > 0) {
@@ -1451,63 +1222,38 @@ var app = new Hono().get("/", async (c) => {
     budget.acknowledgeWarning(baseName);
     forwardBody = JSON.stringify(parsed);
   }
-  let res;
+  typingMap.set(channel, baseName, { persistent: true });
+  const conversationId = parsed?.conversationId ?? null;
+  if (conversationId) typingMap.set(`volute:${conversationId}`, baseName, { persistent: true });
   try {
-    res = await fetch(`http://127.0.0.1:${port}/message`, {
+    const res = await fetch(`http://127.0.0.1:${port}/message`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: forwardBody
     });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      console.error(`[daemon] agent ${name} responded with ${res.status}: ${text}`);
+      return c.json({ error: `Agent responded with ${res.status}` }, res.status);
+    }
+    let result;
+    try {
+      result = await res.json();
+    } catch (parseErr) {
+      console.error(`[daemon] agent ${name} returned non-JSON response:`, parseErr);
+      return c.json({ error: "Agent returned invalid response" }, 502);
+    }
+    if (result.usage) {
+      budget.recordUsage(baseName, result.usage.input_tokens, result.usage.output_tokens);
+    }
+    return c.json({ ok: true });
   } catch (err) {
     console.error(`[daemon] agent ${name} unreachable on port ${port}:`, err);
     return c.json({ error: "Agent is not reachable" }, 502);
+  } finally {
+    typingMap.delete(channel, baseName);
+    if (conversationId) typingMap.delete(`volute:${conversationId}`, baseName);
   }
-  if (!res.ok) {
-    return c.json({ error: `Agent responded with ${res.status}` }, res.status);
-  }
-  if (!res.body) {
-    return c.json({ error: "No response body from agent" }, 502);
-  }
-  c.header("Content-Type", "application/x-ndjson");
-  const encoder = new TextEncoder();
-  typingMap.set(channel, baseName, { persistent: true });
-  return stream(c, async (s) => {
-    try {
-      const textParts = [];
-      const toolParts = [];
-      for await (const event of readNdjson(res.body)) {
-        if (event.type === "usage") {
-          const input = typeof event.input_tokens === "number" ? event.input_tokens : 0;
-          const output = typeof event.output_tokens === "number" ? event.output_tokens : 0;
-          budget.recordUsage(baseName, input, output);
-          continue;
-        }
-        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);
-        }
-      }
-      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 {
-      typingMap.delete(channel, baseName);
-    }
-  });
 }).get("/:name/budget", async (c) => {
   const name = c.req.param("name");
   const [baseName] = name.split("@", 2);
@@ -1526,13 +1272,12 @@ var app = new Hono().get("/", async (c) => {
   if (!body.channel || !body.content) {
     return c.json({ error: "channel and content required" }, 400);
   }
-  const db2 = await getDb();
+  const db = await getDb();
   try {
-    await db2.insert(agentMessages).values({
+    await db.insert(agentMessages).values({
       agent: baseName,
       channel: body.channel,
-      role: "assistant",
-      sender: baseName,
+      sender: body.sender ?? baseName,
       content: body.content
     });
   } catch (err) {
@@ -1542,20 +1287,20 @@ var app = new Hono().get("/", async (c) => {
   return c.json({ ok: true });
 }).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));
+  const db = await getDb();
+  const rows = await db.selectDistinct({ channel: agentMessages.channel }).from(agentMessages).where(eq2(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");
   const limit = Math.min(Math.max(parseInt(c.req.query("limit") ?? "50", 10) || 50, 1), 200);
   const offset = Math.max(parseInt(c.req.query("offset") ?? "0", 10) || 0, 0);
-  const db2 = await getDb();
-  const conditions = [eq3(agentMessages.agent, name)];
+  const db = await getDb();
+  const conditions = [eq2(agentMessages.agent, name)];
   if (channel) {
-    conditions.push(eq3(agentMessages.channel, channel));
+    conditions.push(eq2(agentMessages.channel, channel));
   }
-  const rows = await db2.select().from(agentMessages).where(and2(...conditions)).orderBy(desc(agentMessages.created_at)).limit(limit).offset(offset);
+  const rows = await db.select().from(agentMessages).where(and(...conditions)).orderBy(desc(agentMessages.created_at)).limit(limit).offset(offset);
   return c.json(rows);
 });
 var agents_default = app;
@@ -1658,7 +1403,7 @@ var app3 = new Hono3().get("/:name/connectors", (c) => {
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
   const manager = getConnectorManager();
-  const envCheck = manager.checkConnectorEnv(type, dir);
+  const envCheck = manager.checkConnectorEnv(type, name, dir);
   if (envCheck) {
     return c.json(
       {
@@ -1704,13 +1449,10 @@ var connectors_default = app3;
 
 // src/web/routes/files.ts
 import { existsSync as existsSync5 } from "fs";
-import { readdir, readFile, writeFile } from "fs/promises";
+import { readdir, readFile } from "fs/promises";
 import { resolve as resolve6 } from "path";
-import { zValidator as zValidator2 } from "@hono/zod-validator";
 import { Hono as Hono4 } from "hono";
-import { z as z2 } from "zod";
 var ALLOWED_FILES = /* @__PURE__ */ new Set(["SOUL.md", "MEMORY.md", "CLAUDE.md", "VOLUTE.md"]);
-var saveFileSchema = z2.object({ content: z2.string() });
 var app4 = new Hono4().get("/:name/files", async (c) => {
   const name = c.req.param("name");
   const entry = findAgent(name);
@@ -1736,19 +1478,6 @@ var app4 = new Hono4().get("/:name/files", async (c) => {
   }
   const content = await readFile(filePath, "utf-8");
   return c.json({ filename, content });
-}).put("/:name/files/:filename", zValidator2("json", saveFileSchema), async (c) => {
-  const name = c.req.param("name");
-  const filename = c.req.param("filename");
-  if (!ALLOWED_FILES.has(filename)) {
-    return c.json({ error: "File not allowed" }, 403);
-  }
-  const entry = findAgent(name);
-  if (!entry) return c.json({ error: "Agent not found" }, 404);
-  const dir = agentDir(name);
-  const filePath = resolve6(dir, "home", filename);
-  const { content } = c.req.valid("json");
-  await writeFile(filePath, content);
-  return c.json({ ok: true });
 });
 var files_default = app4;
 
@@ -1762,29 +1491,28 @@ var app5 = new Hono5().get("/:name/logs", 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 logFile = resolve7(dir, ".volute", "logs", "agent.log");
+  const logFile = resolve7(stateDir(name), "logs", "agent.log");
   if (!existsSync6(logFile)) {
     return c.json({ error: "No log file found" }, 404);
   }
-  return streamSSE(c, async (stream2) => {
+  return streamSSE(c, async (stream) => {
     const tail = spawn2("tail", ["-n", "200", "-f", logFile]);
     const onData = (data) => {
       const lines = data.toString().split("\n");
       for (const line of lines) {
         if (line) {
-          stream2.writeSSE({ data: line }).catch(() => {
+          stream.writeSSE({ data: line }).catch(() => {
           });
         }
       }
     };
     tail.stdout.on("data", onData);
-    stream2.onAbort(() => {
+    stream.onAbort(() => {
       tail.kill();
     });
     await new Promise((resolve11) => {
       tail.on("exit", resolve11);
-      stream2.onAbort(resolve11);
+      stream.onAbort(resolve11);
     });
   });
 });
@@ -1878,16 +1606,16 @@ import { streamSSE as streamSSE2 } from "hono/streaming";
 var app7 = new Hono7().get("/logs", async (c) => {
   const user = c.get("user");
   if (user.role !== "admin") return c.json({ error: "Forbidden" }, 403);
-  return streamSSE2(c, async (stream2) => {
+  return streamSSE2(c, async (stream) => {
     for (const entry of logBuffer.getEntries()) {
-      await stream2.writeSSE({ data: JSON.stringify(entry) });
+      await stream.writeSSE({ data: JSON.stringify(entry) });
     }
     const unsubscribe = logBuffer.subscribe((entry) => {
-      stream2.writeSSE({ data: JSON.stringify(entry) }).catch(() => {
+      stream.writeSSE({ data: JSON.stringify(entry) }).catch(() => {
       });
     });
     await new Promise((resolve11) => {
-      stream2.onAbort(() => {
+      stream.onAbort(() => {
         unsubscribe();
         resolve11();
       });
@@ -1897,15 +1625,15 @@ var app7 = new Hono7().get("/logs", async (c) => {
 var system_default = app7;
 
 // src/web/routes/typing.ts
-import { zValidator as zValidator3 } from "@hono/zod-validator";
+import { zValidator as zValidator2 } from "@hono/zod-validator";
 import { Hono as Hono8 } from "hono";
-import { z as z3 } from "zod";
-var typingSchema = z3.object({
-  channel: z3.string().min(1),
-  sender: z3.string().min(1),
-  active: z3.boolean()
+import { z as z2 } from "zod";
+var typingSchema = z2.object({
+  channel: z2.string().min(1),
+  sender: z2.string().min(1),
+  active: z2.boolean()
 });
-var app8 = new Hono8().post("/:name/typing", zValidator3("json", typingSchema), (c) => {
+var app8 = new Hono8().post("/:name/typing", zValidator2("json", typingSchema), (c) => {
   const { channel, sender, active } = c.req.valid("json");
   const map = getTypingMap();
   if (active) {
@@ -1966,18 +1694,46 @@ var variants_default = app10;
 // src/web/routes/volute/chat.ts
 import { readFileSync as readFileSync4 } from "fs";
 import { resolve as resolve8 } from "path";
-import { zValidator as zValidator4 } from "@hono/zod-validator";
+import { zValidator as zValidator3 } from "@hono/zod-validator";
 import { Hono as Hono11 } from "hono";
 import { streamSSE as streamSSE3 } from "hono/streaming";
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
+
+// src/lib/conversation-events.ts
+var subscribers = /* @__PURE__ */ new Map();
+function subscribe(conversationId, callback) {
+  let set = subscribers.get(conversationId);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    subscribers.set(conversationId, set);
+  }
+  set.add(callback);
+  return () => {
+    set.delete(callback);
+    if (set.size === 0) subscribers.delete(conversationId);
+  };
+}
+function publish(conversationId, event) {
+  const set = subscribers.get(conversationId);
+  if (!set) return;
+  for (const cb of set) {
+    try {
+      cb(event);
+    } catch (err) {
+      console.error("[conversation-events] subscriber threw:", err);
+      set.delete(cb);
+      if (set.size === 0) subscribers.delete(conversationId);
+    }
+  }
+}
 
 // src/lib/conversations.ts
 import { randomUUID } from "crypto";
-import { and as and3, desc as desc2, eq as eq4, inArray, isNull, sql as sql2 } from "drizzle-orm";
+import { and as and2, desc as desc2, eq as eq3, inArray, isNull, sql } from "drizzle-orm";
 async function createConversation(agentName, channel, opts) {
-  const db2 = await getDb();
+  const db = await getDb();
   const id = randomUUID();
-  await db2.insert(conversations).values({
+  await db.insert(conversations).values({
     id,
     agent_name: agentName,
     channel,
@@ -1985,7 +1741,7 @@ async function createConversation(agentName, channel, opts) {
     title: opts?.title ?? null
   });
   if (opts?.participantIds && opts.participantIds.length > 0) {
-    await db2.insert(conversationParticipants).values(
+    await db.insert(conversationParticipants).values(
       opts.participantIds.map((uid, i) => ({
         conversation_id: id,
         user_id: uid,
@@ -2004,41 +1760,41 @@ async function createConversation(agentName, channel, opts) {
   };
 }
 async function getConversation(id) {
-  const db2 = await getDb();
-  const row = await db2.select().from(conversations).where(eq4(conversations.id, id)).get();
+  const db = await getDb();
+  const row = await db.select().from(conversations).where(eq3(conversations.id, id)).get();
   return row ?? null;
 }
 async function getParticipants(conversationId) {
-  const db2 = await getDb();
-  const rows = await db2.select({
+  const db = await getDb();
+  const rows = await db.select({
     userId: conversationParticipants.user_id,
     username: users.username,
     userType: users.user_type,
     role: conversationParticipants.role
-  }).from(conversationParticipants).innerJoin(users, eq4(conversationParticipants.user_id, users.id)).where(eq4(conversationParticipants.conversation_id, conversationId)).all();
+  }).from(conversationParticipants).innerJoin(users, eq3(conversationParticipants.user_id, users.id)).where(eq3(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)
+  const db = await getDb();
+  const row = await db.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(
+    and2(
+      eq3(conversationParticipants.conversation_id, conversationId),
+      eq3(conversationParticipants.user_id, userId)
     )
   ).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();
+  const db = await getDb();
+  const participantRows = await db.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(eq3(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();
+  return db.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();
+  const db = await getDb();
+  const row = await db.select().from(conversations).where(and2(eq3(conversations.id, conversationId), eq3(conversations.user_id, userId))).get();
   return row != null;
 }
 async function deleteConversationForUser(id, userId) {
@@ -2047,18 +1803,18 @@ async function deleteConversationForUser(id, userId) {
   return true;
 }
 async function addMessage(conversationId, role, senderName, content) {
-  const db2 = await getDb();
+  const db = await getDb();
   const serialized = JSON.stringify(content);
-  const [result] = await db2.insert(messages).values({ conversation_id: conversationId, role, sender_name: senderName, content: serialized }).returning({ id: messages.id, created_at: messages.created_at });
-  await db2.update(conversations).set({ updated_at: sql2`datetime('now')` }).where(eq4(conversations.id, conversationId));
+  const [result] = await db.insert(messages).values({ conversation_id: conversationId, role, sender_name: senderName, content: serialized }).returning({ id: messages.id, created_at: messages.created_at });
+  await db.update(conversations).set({ updated_at: sql`datetime('now')` }).where(eq3(conversations.id, conversationId));
   if (role === "user") {
     const firstText = content.find((b) => b.type === "text");
     const title = firstText ? firstText.text.slice(0, 80) : "";
     if (title) {
-      await db2.update(conversations).set({ title }).where(and3(eq4(conversations.id, conversationId), isNull(conversations.title)));
+      await db.update(conversations).set({ title }).where(and2(eq3(conversations.id, conversationId), isNull(conversations.title)));
     }
   }
-  return {
+  const msg = {
     id: result.id,
     conversation_id: conversationId,
     role,
@@ -2066,10 +1822,19 @@ async function addMessage(conversationId, role, senderName, content) {
     content,
     created_at: result.created_at
   };
+  publish(conversationId, {
+    type: "message",
+    id: msg.id,
+    role: msg.role,
+    senderName: msg.sender_name,
+    content: msg.content,
+    createdAt: msg.created_at
+  });
+  return msg;
 }
 async function getMessages(conversationId) {
-  const db2 = await getDb();
-  const rows = await db2.select().from(messages).where(eq4(messages.conversation_id, conversationId)).orderBy(messages.created_at).all();
+  const db = await getDb();
+  const rows = await db.select().from(messages).where(eq3(messages.conversation_id, conversationId)).orderBy(messages.created_at).all();
   return rows.map((row) => {
     let content;
     try {
@@ -2084,15 +1849,15 @@ async function getMessages(conversationId) {
 async function listConversationsWithParticipants(userId) {
   const convs = await listConversationsForUser(userId);
   if (convs.length === 0) return [];
-  const db2 = await getDb();
+  const db = await getDb();
   const convIds = convs.map((c) => c.id);
-  const rows = await db2.select({
+  const rows = await db.select({
     conversationId: conversationParticipants.conversation_id,
     userId: users.id,
     username: users.username,
     userType: users.user_type,
     role: conversationParticipants.role
-  }).from(conversationParticipants).innerJoin(users, eq4(conversationParticipants.user_id, users.id)).where(inArray(conversationParticipants.conversation_id, convIds));
+  }).from(conversationParticipants).innerJoin(users, eq3(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);
@@ -2110,10 +1875,10 @@ async function listConversationsWithParticipants(userId) {
   return convs.map((c) => ({ ...c, participants: byConv.get(c.id) ?? [] }));
 }
 async function findDMConversation(agentName, participantIds) {
-  const db2 = await getDb();
-  const agentConvs = await db2.select({ id: conversations.id }).from(conversations).where(eq4(conversations.agent_name, agentName)).all();
+  const db = await getDb();
+  const agentConvs = await db.select({ id: conversations.id }).from(conversations).where(eq3(conversations.agent_name, agentName)).all();
   for (const conv of agentConvs) {
-    const rows = await db2.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(eq4(conversationParticipants.conversation_id, conv.id)).all();
+    const rows = await db.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(eq3(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])) {
@@ -2123,25 +1888,29 @@ async function findDMConversation(agentName, participantIds) {
   return null;
 }
 async function deleteConversation(id) {
-  const db2 = await getDb();
-  await db2.delete(conversations).where(eq4(conversations.id, id));
+  const db = await getDb();
+  await db.delete(conversations).where(eq3(conversations.id, id));
 }
 
 // src/web/routes/volute/chat.ts
-var chatSchema = z4.object({
-  message: z4.string().optional(),
-  conversationId: z4.string().optional(),
-  sender: z4.string().optional(),
-  images: z4.array(
-    z4.object({
-      media_type: z4.string(),
-      data: z4.string()
+var chatSchema = z3.object({
+  message: z3.string().optional(),
+  conversationId: z3.string().optional(),
+  sender: z3.string().optional(),
+  images: z3.array(
+    z3.object({
+      media_type: z3.string(),
+      data: z3.string()
     })
   ).optional()
 });
 function getDaemonUrl() {
-  const data = JSON.parse(readFileSync4(resolve8(voluteHome(), "daemon.json"), "utf-8"));
-  return `http://${daemonLoopback()}:${data.port}`;
+  try {
+    const data = JSON.parse(readFileSync4(resolve8(voluteHome(), "daemon.json"), "utf-8"));
+    return `http://${daemonLoopback()}:${data.port}`;
+  } catch (err) {
+    throw new Error(`Failed to read daemon config: ${err instanceof Error ? err.message : err}`);
+  }
 }
 function daemonFetchInternal(path, body) {
   const daemonUrl = getDaemonUrl();
@@ -2153,40 +1922,7 @@ function daemonFetchInternal(path, body) {
   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 app11 = new Hono11().post("/:name/chat", zValidator4("json", chatSchema), async (c) => {
+var app11 = new Hono11().post("/:name/chat", zValidator3("json", chatSchema), async (c) => {
   const name = c.req.param("name");
   const [baseName] = name.split("@", 2);
   const entry = findAgent(baseName);
@@ -2204,7 +1940,6 @@ var app11 = new Hono11().post("/:name/chat", zValidator4("json", chatSchema), as
       return c.json({ error: "Conversation not found" }, 404);
     }
   } else {
-    const title = body.message ? body.message.slice(0, 80) : "Image message";
     const participantIds = [];
     if (user.id !== 0) {
       participantIds.push(user.id);
@@ -2223,15 +1958,19 @@ var app11 = new Hono11().post("/:name/chat", zValidator4("json", chatSchema), as
       }
     }
     if (!conversationId) {
-      const conv = await createConversation(baseName, "volute", {
+      const participantNames2 = /* @__PURE__ */ new Set([senderName, baseName]);
+      const title = [...participantNames2].join(", ");
+      const conv2 = await createConversation(baseName, "volute", {
         userId: user.id !== 0 ? user.id : void 0,
         title,
         participantIds
       });
-      conversationId = conv.id;
+      conversationId = conv2.id;
     }
   }
-  const channel = `volute:${conversationId}`;
+  const conv = await getConversation(conversationId);
+  const convTitle = conv?.title;
+  const channel = convTitle ? `volute:${slugify(convTitle)}` : `volute:${conversationId}`;
   const contentBlocks = [];
   if (body.message) {
     contentBlocks.push({ type: "text", text: body.message });
@@ -2245,101 +1984,86 @@ var app11 = new Hono11().post("/:name/chat", zValidator4("json", chatSchema), as
   const participants = await getParticipants(conversationId);
   const agentParticipants = participants.filter((p) => p.userType === "agent");
   const participantNames = participants.map((p) => p.username);
-  const { getAgentManager: getAgentManager2 } = await import("./agent-manager-JDVXU3ON.js");
+  const { getAgentManager: getAgentManager2 } = await import("./agent-manager-CMMH5KQQ.js");
   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);
   const isDM = participants.length === 2;
+  const channelEntry = {
+    platformId: conversationId,
+    platform: "volute",
+    name: convTitle ?? void 0,
+    type: isDM ? "dm" : "group"
+  };
+  for (const ap of agentParticipants) {
+    try {
+      writeChannelEntry(ap.username, channel, channelEntry);
+    } catch (err) {
+      console.warn(`[chat] failed to write channel entry for ${ap.username}:`, err);
+    }
+  }
   const typingMap = getTypingMap();
   const currentlyTyping = typingMap.get(channel);
   const payload = JSON.stringify({
     content: contentBlocks,
     channel,
+    conversationId,
     sender: senderName,
     participants: participantNames,
     participantCount: participants.length,
     isDM,
     ...currentlyTyping.length > 0 ? { typing: currentlyTyping } : {}
   });
-  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)}`
-        );
+    daemonFetchInternal(`/api/agents/${encodeURIComponent(targetName)}/message`, payload).then(async (res) => {
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        console.error(`[chat] agent ${agentName} responded ${res.status}: ${text}`);
       }
-    } catch (err) {
+    }).catch((err) => {
       console.error(`[chat] agent ${agentName} unreachable via daemon:`, err);
-    }
-  }
-  if (responses.length === 0) {
-    return streamSSE3(c, async (stream2) => {
-      await stream2.writeSSE({
-        data: JSON.stringify({ type: "meta", conversationId })
-      });
-      await stream2.writeSSE({ data: JSON.stringify({ type: "sync" }) });
     });
   }
-  const primary = responses[0];
-  const secondary = responses.slice(1);
-  const secondaryPromises = secondary.map((s) => consumeAndPersist(s.res, conversationId, s.name));
-  return streamSSE3(c, async (stream2) => {
-    await stream2.writeSSE({
-      data: JSON.stringify({ type: "meta", conversationId, senderName: primary.name })
+  return c.json({ ok: true, conversationId });
+}).get("/:name/conversations/:id/events", async (c) => {
+  const conversationId = c.req.param("id");
+  const user = c.get("user");
+  if (user.id !== 0 && !await isParticipantOrOwner(conversationId, user.id)) {
+    return c.json({ error: "Conversation not found" }, 404);
+  }
+  return streamSSE3(c, async (stream) => {
+    const unsubscribe = subscribe(conversationId, (event) => {
+      stream.writeSSE({ data: JSON.stringify(event) }).catch((err) => {
+        if (!stream.aborted) console.error("[chat] SSE write error:", err);
+      });
     });
-    const assistantContent = [];
-    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;
-      }
-    } catch (err) {
-      console.error(`[chat] error streaming response from ${primary.name}:`, err);
-      await stream2.writeSSE({
-        data: JSON.stringify({ type: "error", message: "Stream interrupted" })
+    const keepAlive = setInterval(() => {
+      stream.writeSSE({ data: "" }).catch((err) => {
+        if (!stream.aborted) console.error("[chat] SSE ping error:", err);
       });
-    }
-    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" }) });
+    }, 15e3);
+    await new Promise((resolve11) => {
+      stream.onAbort(() => {
+        unsubscribe();
+        clearInterval(keepAlive);
+        resolve11();
+      });
+    });
   });
 });
 var chat_default = app11;
 
 // src/web/routes/volute/conversations.ts
-import { zValidator as zValidator5 } from "@hono/zod-validator";
+import { zValidator as zValidator4 } from "@hono/zod-validator";
 import { Hono as Hono12 } from "hono";
-import { z as z5 } from "zod";
-var createConvSchema = z5.object({
-  title: z5.string().optional(),
-  participantIds: z5.array(z5.number()).optional(),
-  participantNames: z5.array(z5.string()).optional()
+import { z as z4 } from "zod";
+var createConvSchema = z4.object({
+  title: z4.string().optional(),
+  participantIds: z4.array(z4.number()).optional(),
+  participantNames: z4.array(z4.string()).optional()
 });
 var app12 = new Hono12().get("/:name/conversations", async (c) => {
   const name = c.req.param("name");
@@ -2352,7 +2076,7 @@ var app12 = new Hono12().get("/:name/conversations", async (c) => {
   const all = await listConversationsForUser(lookupId);
   const convs = all.filter((c2) => c2.agent_name === name);
   return c.json(convs);
-}).post("/:name/conversations", zValidator5("json", createConvSchema), async (c) => {
+}).post("/:name/conversations", zValidator4("json", createConvSchema), async (c) => {
   const name = c.req.param("name");
   const user = c.get("user");
   const body = c.req.valid("json");
@@ -2393,9 +2117,13 @@ var app12 = new Hono12().get("/:name/conversations", async (c) => {
       console.warn(`[conversations] DM conversation ${existingId} found but not retrievable`);
     }
   }
+  let title = body.title;
+  if (!title && body.participantNames?.length) {
+    title = body.participantNames.join(", ");
+  }
   const conv = await createConversation(name, "volute", {
     userId: user.id !== 0 ? user.id : void 0,
-    title: body.title,
+    title,
     participantIds
   });
   return c.json(conv, 201);
@@ -2425,12 +2153,12 @@ var app12 = new Hono12().get("/:name/conversations", async (c) => {
 var conversations_default = app12;
 
 // src/web/routes/volute/user-conversations.ts
-import { zValidator as zValidator6 } from "@hono/zod-validator";
+import { zValidator as zValidator5 } from "@hono/zod-validator";
 import { Hono as Hono13 } from "hono";
-import { z as z6 } from "zod";
-var createSchema = z6.object({
-  title: z6.string().optional(),
-  participantNames: z6.array(z6.string()).min(1)
+import { z as z5 } from "zod";
+var createSchema = z5.object({
+  title: z5.string().optional(),
+  participantNames: z5.array(z5.string()).min(1)
 });
 var app13 = new Hono13().use("*", authMiddleware).get("/", async (c) => {
   const user = c.get("user");
@@ -2444,7 +2172,7 @@ var app13 = new Hono13().use("*", authMiddleware).get("/", async (c) => {
   }
   const msgs = await getMessages(id);
   return c.json(msgs);
-}).post("/", zValidator6("json", createSchema), async (c) => {
+}).post("/", zValidator5("json", createSchema), async (c) => {
   const user = c.get("user");
   const body = c.req.valid("json");
   const participantIds = /* @__PURE__ */ new Set();
@@ -2548,14 +2276,14 @@ async function startServer({
   hostname = "127.0.0.1"
 }) {
   let assetsDir = "";
-  let searchDir = dirname3(new URL(import.meta.url).pathname);
+  let searchDir = dirname2(new URL(import.meta.url).pathname);
   for (let i = 0; i < 5; i++) {
     const candidate = resolve9(searchDir, "dist", "web-assets");
     if (existsSync7(candidate)) {
       assetsDir = candidate;
       break;
     }
-    searchDir = dirname3(searchDir);
+    searchDir = dirname2(searchDir);
   }
   if (assetsDir) {
     app_default.get("*", async (c) => {
@@ -2611,9 +2339,10 @@ async function startDaemon(opts) {
   }
   const DAEMON_PID_PATH = resolve10(home, "daemon.pid");
   const DAEMON_JSON_PATH = resolve10(home, "daemon.json");
-  mkdirSync2(home, { recursive: true });
+  mkdirSync3(home, { recursive: true });
   const token = process.env.VOLUTE_DAEMON_TOKEN || randomBytes(32).toString("hex");
   process.env.VOLUTE_DAEMON_TOKEN = token;
+  process.env.VOLUTE_DAEMON_PORT = String(port);
   process.env.VOLUTE_DAEMON_HOSTNAME = hostname;
   let server;
   try {
@@ -2639,6 +2368,13 @@ async function startDaemon(opts) {
   const tokenBudget = getTokenBudget();
   tokenBudget.start(port, token);
   const registry = readRegistry();
+  for (const entry of registry) {
+    try {
+      migrateAgentState(entry.name);
+    } catch (err) {
+      console.error(`[daemon] failed to migrate state for ${entry.name}:`, err);
+    }
+  }
   for (const entry of registry) {
     if (!entry.running) continue;
     try {