volute 0.5.0 → 0.7.0

package/dist/daemon.js

@@ -6,34 +6,58 @@ import {
   initAgentManager,
   loadJsonMap,
   saveJsonMap
-} from "./chunk-MW2KFO3B.js";
+} from "./chunk-62X577Y7.js";
 import {
   checkForUpdate,
   checkForUpdateCached,
   getCurrentVersion
-} from "./chunk-5X7HGB6L.js";
-import {
-  CHANNELS
-} from "./chunk-SMISE4SV.js";
+} from "./chunk-NKXULRSW.js";
 import {
   collectPart
 } from "./chunk-B3R6L2GW.js";
+import {
+  CHANNELS
+} from "./chunk-ZZOOTYXK.js";
+import {
+  agentMessages,
+  approveUser,
+  conversationParticipants,
+  conversations,
+  createUser,
+  deleteAgentUser,
+  getDb,
+  getOrCreateAgentUser,
+  getUser,
+  getUserByUsername,
+  listPendingUsers,
+  listUsers,
+  listUsersByType,
+  messages,
+  sessions,
+  users,
+  verifyUser
+} from "./chunk-7ACDT3P2.js";
 import {
   readVoluteConfig,
   writeVoluteConfig
 } from "./chunk-NETNFBA5.js";
 import {
   loadMergedEnv
-} from "./chunk-HE67X4T6.js";
+} from "./chunk-H7AMDUIA.js";
+import {
+  slugify,
+  writeChannelEntry
+} from "./chunk-BX7KI4S3.js";
 import {
   applyIsolation
-} from "./chunk-UAVD2AHX.js";
+} from "./chunk-W76KWE23.js";
 import {
   resolveVoluteBin
 } from "./chunk-5SKQ6J7T.js";
 import {
   agentDir,
   checkHealth,
+  daemonLoopback,
   findAgent,
   findVariant,
   getAllRunningVariants,
@@ -44,16 +68,14 @@ import {
   setAgentRunning,
   setVariantRunning,
   voluteHome
-} from "./chunk-UX25Z2ND.js";
-import {
-  __export
-} from "./chunk-K3NQKI34.js";
+} from "./chunk-UWHWAPGO.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 { homedir } from "os";
-import { resolve as resolve10 } from "path";
+import { resolve as resolve9 } from "path";
 import { format } from "util";
 
 // src/lib/connector-manager.ts
@@ -232,7 +254,7 @@ var ConnectorManager = class {
         VOLUTE_AGENT_NAME: agentName,
         VOLUTE_AGENT_DIR: agentDir2,
         ...daemonPort ? {
-          VOLUTE_DAEMON_URL: `http://127.0.0.1:${daemonPort}`,
+          VOLUTE_DAEMON_URL: `http://${daemonLoopback()}:${daemonPort}`,
           VOLUTE_DAEMON_TOKEN: process.env.VOLUTE_DAEMON_TOKEN
         } : {},
         ...connectorEnv
@@ -293,19 +315,19 @@ var ConnectorManager = class {
     const stopKey = `${agentName}:${type}`;
     this.stopping.add(stopKey);
     agentMap.delete(type);
-    await new Promise((resolve11) => {
-      tracked.child.on("exit", () => resolve11());
+    await new Promise((resolve10) => {
+      tracked.child.on("exit", () => resolve10());
       try {
         tracked.child.kill("SIGTERM");
       } catch {
-        resolve11();
+        resolve10();
       }
       setTimeout(() => {
         try {
           tracked.child.kill("SIGKILL");
         } catch {
         }
-        resolve11();
+        resolve10();
       }, 5e3);
     });
     this.stopping.delete(stopKey);
@@ -478,7 +500,7 @@ var Scheduler = class {
     try {
       let res;
       if (this.daemonPort && this.daemonToken) {
-        const daemonUrl = `http://127.0.0.1:${this.daemonPort}`;
+        const daemonUrl = `http://${daemonLoopback()}:${this.daemonPort}`;
         res = await fetch(`${daemonUrl}/api/agents/${encodeURIComponent(agentName)}/message`, {
           method: "POST",
           headers: {
@@ -527,247 +549,185 @@ function getScheduler() {
   return instance2;
 }
 
-// src/web/middleware/auth.ts
-import { timingSafeEqual } from "crypto";
-import { eq as eq2, 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
-    );
+// src/lib/token-budget.ts
+var DEFAULT_BUDGET_PERIOD_MINUTES = 60;
+var MAX_QUEUE_SIZE = 100;
+var TokenBudget = class {
+  budgets = /* @__PURE__ */ new Map();
+  interval = null;
+  daemonPort = null;
+  daemonToken = null;
+  start(daemonPort, daemonToken) {
+    this.daemonPort = daemonPort ?? null;
+    this.daemonToken = daemonToken ?? null;
+    this.interval = setInterval(() => this.tick(), 6e4);
   }
-  return db;
-}
+  stop() {
+    if (this.interval) clearInterval(this.interval);
+    this.interval = null;
+  }
+  setBudget(agent, tokenLimit, periodMinutes) {
+    if (tokenLimit <= 0) return;
+    const existing = this.budgets.get(agent);
+    if (existing) {
+      existing.tokenLimit = tokenLimit;
+      existing.periodMinutes = periodMinutes;
+    } else {
+      this.budgets.set(agent, {
+        tokensUsed: 0,
+        periodStart: Date.now(),
+        periodMinutes,
+        tokenLimit,
+        queue: [],
+        warningInjected: false
+      });
+    }
+  }
+  removeBudget(agent) {
+    this.budgets.delete(agent);
+  }
+  recordUsage(agent, inputTokens, outputTokens) {
+    const state = this.budgets.get(agent);
+    if (!state) return;
+    state.tokensUsed += inputTokens + outputTokens;
+  }
+  /** Returns current budget status. Does not mutate state — call acknowledgeWarning() after delivering a warning. */
+  checkBudget(agent) {
+    const state = this.budgets.get(agent);
+    if (!state) return "ok";
+    const pct = state.tokensUsed / state.tokenLimit;
+    if (pct >= 1) return "exceeded";
+    if (pct >= 0.8 && !state.warningInjected) return "warning";
+    return "ok";
+  }
+  /** Mark warning as delivered for this period. Call after successfully injecting the warning. */
+  acknowledgeWarning(agent) {
+    const state = this.budgets.get(agent);
+    if (state) state.warningInjected = true;
+  }
+  enqueue(agent, message) {
+    const state = this.budgets.get(agent);
+    if (!state) return;
+    if (state.queue.length >= MAX_QUEUE_SIZE) {
+      state.queue.shift();
+    }
+    state.queue.push(message);
+  }
+  drain(agent) {
+    const state = this.budgets.get(agent);
+    if (!state) return [];
+    const messages2 = state.queue;
+    state.queue = [];
+    return messages2;
+  }
+  getUsage(agent) {
+    const state = this.budgets.get(agent);
+    if (!state) return null;
+    return {
+      tokensUsed: state.tokensUsed,
+      tokenLimit: state.tokenLimit,
+      periodMinutes: state.periodMinutes,
+      periodStart: state.periodStart,
+      queueLength: state.queue.length,
+      percentUsed: Math.round(state.tokensUsed / state.tokenLimit * 100)
+    };
+  }
+  tick() {
+    const now = Date.now();
+    for (const [agent, state] of this.budgets) {
+      const elapsed = now - state.periodStart;
+      if (elapsed >= state.periodMinutes * 6e4) {
+        state.tokensUsed = 0;
+        state.periodStart = now;
+        state.warningInjected = false;
+        const queued = this.drain(agent);
+        if (queued.length > 0) {
+          this.replay(agent, queued).catch((err) => {
+            console.error(`[token-budget] replay error for ${agent}:`, err);
+          });
+        }
+      }
+    }
+  }
+  async replay(agentName, messages2) {
+    if (!this.daemonPort || !this.daemonToken) {
+      console.error(
+        `[token-budget] cannot replay ${messages2.length} message(s) for ${agentName}: daemon not configured`
+      );
+      const state = this.budgets.get(agentName);
+      if (state) state.queue.push(...messages2);
+      return;
+    }
+    const summary = messages2.map((m) => {
+      const from = m.sender ? `[${m.sender}]` : "";
+      const ch = m.channel ? `(${m.channel})` : "";
+      return `${from}${ch} ${m.textContent}`;
+    }).join("\n");
+    const body = JSON.stringify({
+      content: [
+        {
+          type: "text",
+          text: `[Budget replay] ${messages2.length} queued message(s) from the previous budget period:
 
-// 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
+${summary}`
+        }
+      ],
+      channel: "system:budget-replay",
+      sender: "system"
     });
-    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;
+    const daemonUrl = `http://${daemonLoopback()}:${this.daemonPort}`;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 12e4);
+    try {
+      const res = await fetch(`${daemonUrl}/api/agents/${encodeURIComponent(agentName)}/message`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.daemonToken}`,
+          Origin: daemonUrl
+        },
+        body,
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        console.error(`[token-budget] replay for ${agentName} got HTTP ${res.status}`);
+      } else {
+        console.error(
+          `[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 {
+      }
+    } catch (err) {
+      console.error(`[token-budget] failed to replay for ${agentName}:`, err);
+      const state = this.budgets.get(agentName);
+      if (state) state.queue.push(...messages2);
+    } finally {
+      clearTimeout(timeout);
     }
-    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")));
+};
+var instance3 = null;
+function getTokenBudget() {
+  if (!instance3) instance3 = new TokenBudget();
+  return instance3;
 }
 
 // src/web/middleware/auth.ts
+import { timingSafeEqual } from "crypto";
+import { eq, lt } from "drizzle-orm";
+import { getCookie } from "hono/cookie";
+import { createMiddleware } from "hono/factory";
 function isValidDaemonToken(token) {
   const expected = process.env.VOLUTE_DAEMON_TOKEN;
   if (!expected || token.length !== expected.length) return false;
@@ -775,29 +735,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");
@@ -828,9 +788,9 @@ var authMiddleware = createMiddleware(async (c, next) => {
 });
 
 // src/web/server.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync6 } 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 resolve8 } from "path";
 import { serve } from "@hono/node-server";
 
 // src/lib/log-buffer.ts
@@ -878,15 +838,15 @@ var log = {
 var logger_default = log;
 
 // src/web/app.ts
-import { Hono as Hono13 } from "hono";
+import { Hono as Hono14 } 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 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 { existsSync as existsSync3, readFileSync as readFileSync3, rmSync } from "fs";
+import { resolve as resolve4 } from "path";
+import { and, desc, eq as eq2 } from "drizzle-orm";
 import { Hono } from "hono";
 import { stream } from "hono/streaming";
 
@@ -929,10 +889,77 @@ async function* readNdjson(body) {
   }
 }
 
+// src/lib/typing.ts
+var DEFAULT_TTL_MS = 1e4;
+var SWEEP_INTERVAL_MS = 5e3;
+var TypingMap = class {
+  channels = /* @__PURE__ */ new Map();
+  sweepTimer;
+  constructor() {
+    this.sweepTimer = setInterval(() => this.sweep(), SWEEP_INTERVAL_MS);
+    this.sweepTimer.unref();
+  }
+  set(channel, sender, opts) {
+    const expiresAt = opts?.persistent ? Infinity : Date.now() + (opts?.ttlMs ?? DEFAULT_TTL_MS);
+    let senders = this.channels.get(channel);
+    if (!senders) {
+      senders = /* @__PURE__ */ new Map();
+      this.channels.set(channel, senders);
+    }
+    senders.set(sender, { expiresAt });
+  }
+  delete(channel, sender) {
+    const senders = this.channels.get(channel);
+    if (senders) {
+      senders.delete(sender);
+      if (senders.size === 0) {
+        this.channels.delete(channel);
+      }
+    }
+  }
+  get(channel) {
+    const senders = this.channels.get(channel);
+    if (!senders) return [];
+    const now = Date.now();
+    const result = [];
+    for (const [sender, entry] of senders) {
+      if (entry.expiresAt > now) {
+        result.push(sender);
+      }
+    }
+    return result;
+  }
+  dispose() {
+    clearInterval(this.sweepTimer);
+    this.channels.clear();
+    if (instance4 === this) instance4 = void 0;
+  }
+  sweep() {
+    const now = Date.now();
+    for (const [channel, senders] of this.channels) {
+      for (const [sender, entry] of senders) {
+        if (entry.expiresAt <= now) {
+          senders.delete(sender);
+        }
+      }
+      if (senders.size === 0) {
+        this.channels.delete(channel);
+      }
+    }
+  }
+};
+var instance4;
+function getTypingMap() {
+  if (!instance4) {
+    instance4 = new TypingMap();
+  }
+  return instance4;
+}
+
 // src/web/routes/agents.ts
 function getDaemonPort() {
   try {
-    const data = JSON.parse(readFileSync3(resolve5(voluteHome(), "daemon.json"), "utf-8"));
+    const data = JSON.parse(readFileSync3(resolve4(voluteHome(), "daemon.json"), "utf-8"));
     return data.port;
   } catch {
     return void 0;
@@ -945,21 +972,25 @@ async function getAgentStatus(name, port) {
     const health = await checkHealth(port);
     status = health.ok ? "running" : "starting";
   }
+  const channelConfig = readVoluteConfig(agentDir(name))?.channels;
   const channels = [];
-  channels.push({
-    name: CHANNELS.volute.name,
-    displayName: CHANNELS.volute.displayName,
-    status: status === "running" ? "connected" : "disconnected",
-    showToolCalls: CHANNELS.volute.showToolCalls
-  });
+  for (const [, provider] of Object.entries(CHANNELS)) {
+    if (!provider.builtIn) continue;
+    channels.push({
+      name: provider.name,
+      displayName: provider.displayName,
+      status: status === "running" ? "connected" : "disconnected",
+      showToolCalls: channelConfig?.[provider.name]?.showToolCalls ?? provider.showToolCalls
+    });
+  }
   const connectorStatuses = getConnectorManager().getConnectorStatus(name);
   for (const cs of connectorStatuses) {
-    const config = CHANNELS[cs.type];
+    const provider = CHANNELS[cs.type];
     channels.push({
-      name: config?.name ?? cs.type,
-      displayName: config?.displayName ?? cs.type,
+      name: provider?.name ?? cs.type,
+      displayName: provider?.displayName ?? cs.type,
       status: cs.running ? "connected" : "disconnected",
-      showToolCalls: config?.showToolCalls ?? false
+      showToolCalls: channelConfig?.[cs.type]?.showToolCalls ?? provider?.showToolCalls ?? false
     });
   }
   return { status, channels };
@@ -977,7 +1008,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 (!existsSync4(agentDir(name))) return c.json({ error: "Agent directory missing" }, 404);
+  if (!existsSync3(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();
@@ -1003,7 +1034,7 @@ var app = new Hono().get("/", async (c) => {
     if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
   } else {
     const dir = agentDir(baseName);
-    if (!existsSync4(dir)) return c.json({ error: "Agent directory missing" }, 404);
+    if (!existsSync3(dir)) return c.json({ error: "Agent directory missing" }, 404);
   }
   const manager = getAgentManager();
   if (manager.isRunning(name)) {
@@ -1015,6 +1046,14 @@ var app = new Hono().get("/", async (c) => {
       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
+        );
+      }
     }
     return c.json({ ok: true });
   } catch (err) {
@@ -1030,13 +1069,16 @@ var app = new Hono().get("/", async (c) => {
     if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
   } else {
     const dir = agentDir(baseName);
-    if (!existsSync4(dir)) return c.json({ error: "Agent directory missing" }, 404);
+    if (!existsSync3(dir)) return c.json({ error: "Agent directory missing" }, 404);
   }
   const manager = getAgentManager();
   const connectorManager = getConnectorManager();
   try {
     if (manager.isRunning(name)) {
-      if (!variantName) await connectorManager.stopConnectors(baseName);
+      if (!variantName) {
+        await connectorManager.stopConnectors(baseName);
+        getTokenBudget().removeBudget(baseName);
+      }
       await manager.stopAgent(name);
     }
     await manager.startAgent(name);
@@ -1044,6 +1086,14 @@ var app = new Hono().get("/", async (c) => {
       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
+        );
+      }
     }
     return c.json({ ok: true });
   } catch (err) {
@@ -1066,6 +1116,7 @@ var app = new Hono().get("/", async (c) => {
     if (!variantName) {
       await getConnectorManager().stopConnectors(baseName);
       getScheduler().unloadSchedules(baseName);
+      getTokenBudget().removeBudget(baseName);
     }
     await manager.stopAgent(name);
     return c.json({ ok: true });
@@ -1081,11 +1132,13 @@ var app = new Hono().get("/", async (c) => {
   const manager = getAgentManager();
   if (manager.isRunning(name)) {
     await getConnectorManager().stopConnectors(name);
+    getTokenBudget().removeBudget(name);
     await manager.stopAgent(name);
   }
   removeAllVariants(name);
   removeAgent(name);
-  if (force && existsSync4(dir)) {
+  await deleteAgentUser(name);
+  if (force && existsSync3(dir)) {
     rmSync(dir, { recursive: true, force: true });
   }
   return c.json({ ok: true });
@@ -1111,10 +1164,10 @@ 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;
+      const sender2 = parsed.sender ?? null;
       let content;
       if (typeof parsed.content === "string") {
         content = parsed.content;
@@ -1123,23 +1176,74 @@ var app = new Hono().get("/", async (c) => {
       } else {
         content = JSON.stringify(parsed.content);
       }
-      await db2.insert(agentMessages).values({
+      await db.insert(agentMessages).values({
         agent: baseName,
         channel,
         role: "user",
-        sender,
+        sender: sender2,
         content
       });
     } catch (err) {
       console.error(`[daemon] failed to persist inbound message for ${baseName}:`, err);
     }
   }
+  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");
+      }
+    }
+    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" })}
+`));
+    });
+  }
+  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) {
+    parsed.typing = currentlyTyping;
+    forwardBody = JSON.stringify(parsed);
+  }
+  if (budgetStatus === "warning" && parsed) {
+    const usage = budget.getUsage(baseName);
+    const pct = usage?.percentUsed ?? 80;
+    const warningText = `
+[System: Token budget is at ${pct}% \u2014 conserve tokens to avoid message queuing]`;
+    if (typeof parsed.content === "string") {
+      parsed.content = parsed.content + warningText;
+    } else if (Array.isArray(parsed.content)) {
+      parsed.content = [...parsed.content, { type: "text", text: warningText }];
+    }
+    budget.acknowledgeWarning(baseName);
+    forwardBody = JSON.stringify(parsed);
+  }
   let res;
   try {
     res = await fetch(`http://127.0.0.1:${port}/message`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body
+      body: forwardBody
     });
   } catch (err) {
     console.error(`[daemon] agent ${name} unreachable on port ${port}:`, err);
@@ -1153,49 +1257,92 @@ var app = new Hono().get("/", async (c) => {
   }
   c.header("Content-Type", "application/x-ndjson");
   const encoder = new TextEncoder();
+  typingMap.set(channel, baseName, { persistent: true });
   return stream(c, async (s) => {
-    const textParts = [];
-    const toolParts = [];
-    for await (const event of readNdjson(res.body)) {
-      await s.write(encoder.encode(`${JSON.stringify(event)}
+    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 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);
+      const content = [textParts.join(""), ...toolParts].filter(Boolean).join("\n");
+      if (content) {
+        try {
+          await db.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);
+  const usage = getTokenBudget().getUsage(baseName);
+  if (!usage) return c.json({ error: "No budget configured" }, 404);
+  return c.json(usage);
+}).post("/:name/history", async (c) => {
+  const name = c.req.param("name");
+  const [baseName] = name.split("@", 2);
+  let body;
+  try {
+    body = await c.req.json();
+  } catch {
+    return c.json({ error: "Invalid JSON" }, 400);
+  }
+  if (!body.channel || !body.content) {
+    return c.json({ error: "channel and content required" }, 400);
+  }
+  const db = await getDb();
+  try {
+    await db.insert(agentMessages).values({
+      agent: baseName,
+      channel: body.channel,
+      role: "assistant",
+      sender: baseName,
+      content: body.content
+    });
+  } catch (err) {
+    console.error(`[daemon] failed to persist external send for ${baseName}:`, err);
+    return c.json({ error: "Failed to persist" }, 500);
+  }
+  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;
@@ -1271,94 +1418,431 @@ var app2 = new Hono2().post("/register", zValidator("json", credentialsSchema),
 }).route("/", admin);
 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";
+// src/web/routes/connectors.ts
 import { Hono as Hono3 } from "hono";
-import { streamSSE } from "hono/streaming";
-import { z as z2 } from "zod";
-
-// 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";
-async function createConversation(agentName, channel, opts) {
-  const db2 = await getDb();
-  const id = randomUUID();
-  await db2.insert(conversations).values({
-    id,
-    agent_name: agentName,
-    channel,
-    user_id: opts?.userId ?? null,
-    title: opts?.title ?? null
+var CONNECTOR_TYPE_RE = /^[a-z][a-z0-9-]*$/;
+var app3 = new Hono3().get("/:name/connectors", (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 config = readVoluteConfig(dir) ?? {};
+  const configured = config.connectors ?? [];
+  const manager = getConnectorManager();
+  const runningStatus = manager.getConnectorStatus(name);
+  const connectors = configured.map((type) => {
+    const status = runningStatus.find((s) => s.type === type);
+    return { type, running: status?.running ?? false };
   });
-  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 c.json(connectors);
+}).post("/:name/connectors/:type", requireAdmin, async (c) => {
+  const name = c.req.param("name");
+  const type = c.req.param("type");
+  if (!CONNECTOR_TYPE_RE.test(type)) {
+    return c.json({ error: "Invalid connector type" }, 400);
+  }
+  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
     );
   }
-  return {
-    id,
-    agent_name: agentName,
-    channel,
-    user_id: opts?.userId ?? null,
-    title: opts?.title ?? null,
-    created_at: (/* @__PURE__ */ new Date()).toISOString(),
-    updated_at: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-async function getParticipants(conversationId) {
-  const db2 = await getDb();
-  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 config = readVoluteConfig(dir) ?? {};
+  const connectors = config.connectors ?? [];
+  if (!connectors.includes(type)) {
+    config.connectors = [...connectors, type];
+    writeVoluteConfig(dir, config);
+  }
+  try {
+    await manager.startConnector(name, dir, entry.port, type);
+    return c.json({ ok: true });
+  } catch (err) {
+    return c.json(
+      { error: err instanceof Error ? err.message : "Failed to start connector" },
+      500
+    );
+  }
+}).delete("/:name/connectors/:type", requireAdmin, async (c) => {
+  const name = c.req.param("name");
+  const type = c.req.param("type");
+  if (!CONNECTOR_TYPE_RE.test(type)) {
+    return c.json({ error: "Invalid connector type" }, 400);
+  }
+  const entry = findAgent(name);
+  if (!entry) return c.json({ error: "Agent not found" }, 404);
+  const dir = agentDir(name);
+  const manager = getConnectorManager();
+  await manager.stopConnector(name, type);
+  const config = readVoluteConfig(dir) ?? {};
+  config.connectors = (config.connectors ?? []).filter((t) => t !== type);
+  writeVoluteConfig(dir, config);
+  return c.json({ ok: true });
+});
+var connectors_default = app3;
+
+// src/web/routes/files.ts
+import { existsSync as existsSync4 } from "fs";
+import { readdir, readFile, writeFile } from "fs/promises";
+import { resolve as resolve5 } 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);
+  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 allFiles = await readdir(homeDir);
+  const files = allFiles.filter((f) => f.endsWith(".md") && ALLOWED_FILES.has(f));
+  return c.json(files);
+}).get("/:name/files/:filename", 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 = resolve5(dir, "home", filename);
+  if (!existsSync4(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", 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 = resolve5(dir, "home", filename);
+  const { content } = c.req.valid("json");
+  await writeFile(filePath, content);
+  return c.json({ ok: true });
+});
+var files_default = app4;
+
+// 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 { Hono as Hono5 } from "hono";
+import { streamSSE } from "hono/streaming";
+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 = resolve6(dir, ".volute", "logs", "agent.log");
+  if (!existsSync5(logFile)) {
+    return c.json({ error: "No log file found" }, 404);
+  }
+  return streamSSE(c, async (stream2) => {
+    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(() => {
+          });
+        }
+      }
+    };
+    tail.stdout.on("data", onData);
+    stream2.onAbort(() => {
+      tail.kill();
+    });
+    await new Promise((resolve10) => {
+      tail.on("exit", resolve10);
+      stream2.onAbort(resolve10);
+    });
+  });
+});
+var logs_default = app5;
+
+// src/web/routes/schedules.ts
+import { Hono as Hono6 } from "hono";
+function readSchedules(name) {
+  return readVoluteConfig(agentDir(name))?.schedules ?? [];
+}
+function writeSchedules(name, schedules) {
+  const dir = agentDir(name);
+  const config = readVoluteConfig(dir) ?? {};
+  config.schedules = schedules.length > 0 ? schedules : void 0;
+  writeVoluteConfig(dir, config);
+  getScheduler().loadSchedules(name);
+}
+var app6 = new Hono6().get("/:name/schedules", (c) => {
+  const name = c.req.param("name");
+  if (!findAgent(name)) return c.json({ error: "Agent not found" }, 404);
+  return c.json(readSchedules(name));
+}).post("/:name/schedules", requireAdmin, async (c) => {
+  const name = c.req.param("name");
+  if (!findAgent(name)) return c.json({ error: "Agent not found" }, 404);
+  const body = await c.req.json();
+  if (!body.cron || !body.message) {
+    return c.json({ error: "cron and message are required" }, 400);
+  }
+  const schedules = readSchedules(name);
+  const id = body.id || `schedule-${Date.now()}`;
+  if (schedules.some((s) => s.id === id)) {
+    return c.json({ error: `Schedule "${id}" already exists` }, 409);
+  }
+  schedules.push({ id, cron: body.cron, message: body.message, enabled: body.enabled ?? true });
+  writeSchedules(name, schedules);
+  return c.json({ ok: true, id }, 201);
+}).put("/:name/schedules/:id", requireAdmin, async (c) => {
+  const name = c.req.param("name");
+  const id = c.req.param("id");
+  if (!findAgent(name)) return c.json({ error: "Agent not found" }, 404);
+  const schedules = readSchedules(name);
+  const idx = schedules.findIndex((s) => s.id === id);
+  if (idx === -1) return c.json({ error: "Schedule not found" }, 404);
+  const body = await c.req.json();
+  if (body.cron !== void 0) schedules[idx].cron = body.cron;
+  if (body.message !== void 0) schedules[idx].message = body.message;
+  if (body.enabled !== void 0) schedules[idx].enabled = body.enabled;
+  writeSchedules(name, schedules);
+  return c.json({ ok: true });
+}).delete("/:name/schedules/:id", requireAdmin, (c) => {
+  const name = c.req.param("name");
+  const id = c.req.param("id");
+  if (!findAgent(name)) return c.json({ error: "Agent not found" }, 404);
+  const schedules = readSchedules(name);
+  const filtered = schedules.filter((s) => s.id !== id);
+  if (filtered.length === schedules.length) {
+    return c.json({ error: "Schedule not found" }, 404);
+  }
+  writeSchedules(name, filtered);
+  return c.json({ ok: true });
+}).post("/:name/webhook/:event", async (c) => {
+  const name = c.req.param("name");
+  const event = c.req.param("event");
+  const entry = findAgent(name);
+  if (!entry) return c.json({ error: "Agent not found" }, 404);
+  const body = await c.req.text();
+  const message = `[webhook: ${event}] ${body}`;
+  try {
+    const res = await fetch(`http://127.0.0.1:${entry.port}/message`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        content: [{ type: "text", text: message }],
+        channel: "system:webhook",
+        sender: "webhook"
+      })
+    });
+    if (!res.ok) {
+      return c.json({ error: `Agent responded with ${res.status}` }, 502);
+    }
+    return c.json({ ok: true });
+  } catch {
+    return c.json({ error: "Failed to reach agent" }, 502);
+  }
+});
+var schedules_default = app6;
+
+// src/web/routes/system.ts
+import { Hono as Hono7 } from "hono";
+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) => {
+    for (const entry of logBuffer.getEntries()) {
+      await stream2.writeSSE({ data: JSON.stringify(entry) });
+    }
+    const unsubscribe = logBuffer.subscribe((entry) => {
+      stream2.writeSSE({ data: JSON.stringify(entry) }).catch(() => {
+      });
+    });
+    await new Promise((resolve10) => {
+      stream2.onAbort(() => {
+        unsubscribe();
+        resolve10();
+      });
+    });
+  });
+});
+var system_default = app7;
+
+// src/web/routes/typing.ts
+import { zValidator as zValidator3 } 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()
+});
+var app8 = new Hono8().post("/:name/typing", zValidator3("json", typingSchema), (c) => {
+  const { channel, sender, active } = c.req.valid("json");
+  const map = getTypingMap();
+  if (active) {
+    map.set(channel, sender);
+  } else {
+    map.delete(channel, sender);
+  }
+  return c.json({ ok: true });
+}).get("/:name/typing", (c) => {
+  const channel = c.req.query("channel");
+  if (!channel) {
+    return c.json({ error: "channel query param is required" }, 400);
+  }
+  const map = getTypingMap();
+  return c.json({ typing: map.get(channel) });
+});
+var typing_default = app8;
+
+// src/web/routes/update.ts
+import { spawn as spawn3 } from "child_process";
+import { Hono as Hono9 } from "hono";
+var bin;
+var app9 = new Hono9().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 = app9;
+
+// src/web/routes/variants.ts
+import { Hono as Hono10 } from "hono";
+var app10 = new Hono10().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);
+  const variants = readVariants(name);
+  const results = await Promise.all(
+    variants.map(async (v) => {
+      if (!v.port) return { ...v, status: "no-server" };
+      const health = await checkHealth(v.port);
+      return { ...v, status: health.ok ? "running" : "dead" };
+    })
+  );
+  return c.json(results);
+});
+var variants_default = app10;
+
+// src/web/routes/volute/chat.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve7 } from "path";
+import { zValidator as zValidator4 } from "@hono/zod-validator";
+import { Hono as Hono11 } from "hono";
+import { streamSSE as streamSSE3 } from "hono/streaming";
+import { z as z4 } from "zod";
+
+// src/lib/conversations.ts
+import { randomUUID } from "crypto";
+import { and as and2, desc as desc2, eq as eq3, inArray, isNull, sql } from "drizzle-orm";
+async function createConversation(agentName, channel, opts) {
+  const db = await getDb();
+  const id = randomUUID();
+  await db.insert(conversations).values({
+    id,
+    agent_name: agentName,
+    channel,
+    user_id: opts?.userId ?? null,
+    title: opts?.title ?? null
+  });
+  if (opts?.participantIds && opts.participantIds.length > 0) {
+    await db.insert(conversationParticipants).values(
+      opts.participantIds.map((uid, i) => ({
+        conversation_id: id,
+        user_id: uid,
+        role: i === 0 ? "owner" : "member"
+      }))
+    );
+  }
+  return {
+    id,
+    agent_name: agentName,
+    channel,
+    user_id: opts?.userId ?? null,
+    title: opts?.title ?? null,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function getConversation(id) {
+  const db = await getDb();
+  const row = await db.select().from(conversations).where(eq3(conversations.id, id)).get();
+  return row ?? null;
+}
+async function getParticipants(conversationId) {
+  const db = await getDb();
+  const rows = await db.select({
+    userId: conversationParticipants.user_id,
+    username: users.username,
+    userType: users.user_type,
+    role: conversationParticipants.role
+  }).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 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 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 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 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) {
   if (!await isParticipantOrOwner(id, userId)) return false;
   await deleteConversation(id);
   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 {
@@ -1371,8 +1855,8 @@ async function addMessage(conversationId, role, senderName, content) {
   };
 }
 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 {
@@ -1387,15 +1871,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);
@@ -1412,26 +1896,39 @@ async function listConversationsWithParticipants(userId) {
   }
   return convs.map((c) => ({ ...c, participants: byConv.get(c.id) ?? [] }));
 }
+async function findDMConversation(agentName, participantIds) {
+  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 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])) {
+      return conv.id;
+    }
+  }
+  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/chat.ts
-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(),
-      data: z2.string()
+// 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()
     })
   ).optional()
 });
 function getDaemonUrl() {
-  const data = JSON.parse(readFileSync4(resolve6(voluteHome(), "daemon.json"), "utf-8"));
-  return `http://127.0.0.1:${data.port}`;
+  const data = JSON.parse(readFileSync4(resolve7(voluteHome(), "daemon.json"), "utf-8"));
+  return `http://${daemonLoopback()}:${data.port}`;
 }
 function daemonFetchInternal(path, body) {
   const daemonUrl = getDaemonUrl();
@@ -1476,15 +1973,11 @@ async function consumeAndPersist(res, conversationId, agentName) {
   }
   return assistantContent;
 }
-var app3 = new Hono3().post("/:name/chat", zValidator2("json", chatSchema), async (c) => {
+var app11 = new Hono11().post("/:name/chat", zValidator4("json", chatSchema), async (c) => {
   const name = c.req.param("name");
   const [baseName] = name.split("@", 2);
   const entry = findAgent(baseName);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
-  const { getAgentManager: getAgentManager2 } = await import("./agent-manager-PXBKA2GK.js");
-  if (!getAgentManager2().isRunning(name)) {
-    return c.json({ error: "Agent is not running" }, 409);
-  }
   const body = c.req.valid("json");
   if (!body.message && (!body.images || body.images.length === 0)) {
     return c.json({ error: "message or images required" }, 400);
@@ -1510,14 +2003,24 @@ var app3 = new Hono3().post("/:name/chat", zValidator2("json", chatSchema), asyn
       }
     }
     participantIds.push(agentUser.id);
-    const conv = await createConversation(baseName, "volute", {
-      userId: user.id !== 0 ? user.id : void 0,
-      title,
-      participantIds
-    });
-    conversationId = conv.id;
+    if (participantIds.length === 2) {
+      const existing = await findDMConversation(baseName, participantIds);
+      if (existing) {
+        conversationId = existing;
+      }
+    }
+    if (!conversationId) {
+      const conv2 = await createConversation(baseName, "volute", {
+        userId: user.id !== 0 ? user.id : void 0,
+        title,
+        participantIds
+      });
+      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 });
@@ -1531,22 +2034,30 @@ var app3 = new Hono3().post("/:name/chat", zValidator2("json", chatSchema), asyn
   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-IMZ7ZMBF.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);
-  if (runningAgents.length === 0) {
-    return c.json({ error: "No running agents in this conversation" }, 409);
-  }
   const isDM = participants.length === 2;
+  const dir = agentDir(baseName);
+  writeChannelEntry(dir, channel, {
+    platformId: conversationId,
+    platform: "volute",
+    name: convTitle ?? void 0,
+    type: isDM ? "dm" : "group"
+  });
+  const typingMap = getTypingMap();
+  const currentlyTyping = typingMap.get(channel);
   const payload = JSON.stringify({
     content: contentBlocks,
     channel,
     sender: senderName,
     participants: participantNames,
     participantCount: participants.length,
-    isDM
+    isDM,
+    ...currentlyTyping.length > 0 ? { typing: currentlyTyping } : {}
   });
   const responses = [];
   for (const agentName of runningAgents) {
@@ -1569,130 +2080,64 @@ var app3 = new Hono3().post("/:name/chat", zValidator2("json", chatSchema), asyn
     }
   }
   if (responses.length === 0) {
-    return c.json({ error: "No agents reachable" }, 502);
+    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 streamSSE(c, async (stream2) => {
+  return streamSSE3(c, async (stream2) => {
     await stream2.writeSSE({
-      data: JSON.stringify({ type: "meta", conversationId, senderName: primary.name })
-    });
-    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" })
-      });
-    }
-    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;
-
-// src/web/routes/connectors.ts
-import { Hono as Hono4 } from "hono";
-var CONNECTOR_TYPE_RE = /^[a-z][a-z0-9-]*$/;
-var app4 = new Hono4().get("/:name/connectors", (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 config = readVoluteConfig(dir) ?? {};
-  const configured = config.connectors ?? [];
-  const manager = getConnectorManager();
-  const runningStatus = manager.getConnectorStatus(name);
-  const connectors = configured.map((type) => {
-    const status = runningStatus.find((s) => s.type === type);
-    return { type, running: status?.running ?? false };
-  });
-  return c.json(connectors);
-}).post("/:name/connectors/:type", requireAdmin, async (c) => {
-  const name = c.req.param("name");
-  const type = c.req.param("type");
-  if (!CONNECTOR_TYPE_RE.test(type)) {
-    return c.json({ error: "Invalid connector type" }, 400);
-  }
-  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);
-  }
-  try {
-    await manager.startConnector(name, dir, entry.port, type);
-    return c.json({ ok: true });
-  } catch (err) {
-    return c.json(
-      { error: err instanceof Error ? err.message : "Failed to start connector" },
-      500
-    );
-  }
-}).delete("/:name/connectors/:type", requireAdmin, async (c) => {
-  const name = c.req.param("name");
-  const type = c.req.param("type");
-  if (!CONNECTOR_TYPE_RE.test(type)) {
-    return c.json({ error: "Invalid connector type" }, 400);
-  }
-  const entry = findAgent(name);
-  if (!entry) return c.json({ error: "Agent not found" }, 404);
-  const dir = agentDir(name);
-  const manager = getConnectorManager();
-  await manager.stopConnector(name, type);
-  const config = readVoluteConfig(dir) ?? {};
-  config.connectors = (config.connectors ?? []).filter((t) => t !== type);
-  writeVoluteConfig(dir, config);
-  return c.json({ ok: true });
+      data: JSON.stringify({ type: "meta", conversationId, senderName: primary.name })
+    });
+    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" })
+      });
+    }
+    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 connectors_default = app4;
+var chat_default = app11;
 
-// 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()
+// src/web/routes/volute/conversations.ts
+import { zValidator as zValidator5 } 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()
 });
-var app5 = new Hono5().get("/:name/conversations", async (c) => {
+var app12 = new Hono12().get("/:name/conversations", async (c) => {
   const name = c.req.param("name");
   const user = c.get("user");
   let lookupId = user.id;
@@ -1703,7 +2148,7 @@ var app5 = new Hono5().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", zValidator3("json", createConvSchema), async (c) => {
+}).post("/:name/conversations", zValidator5("json", createConvSchema), async (c) => {
   const name = c.req.param("name");
   const user = c.get("user");
   const body = c.req.valid("json");
@@ -1735,10 +2180,19 @@ var app5 = new Hono5().get("/:name/conversations", async (c) => {
     const u = await getUser(id);
     if (!u) return c.json({ error: `User ${id} not found` }, 400);
   }
+  const participantIds = [...participantSet];
+  if (participantIds.length === 2) {
+    const existingId = await findDMConversation(name, participantIds);
+    if (existingId) {
+      const conv2 = await getConversation(existingId);
+      if (conv2) return c.json(conv2);
+      console.warn(`[conversations] DM conversation ${existingId} found but not retrievable`);
+    }
+  }
   const conv = await createConversation(name, "volute", {
     userId: user.id !== 0 ? user.id : void 0,
     title: body.title,
-    participantIds: [...participantSet]
+    participantIds
   });
   return c.json(conv, 201);
 }).get("/:name/conversations/:id/messages", async (c) => {
@@ -1752,7 +2206,7 @@ var app5 = new Hono5().get("/:name/conversations", async (c) => {
 }).get("/:name/conversations/:id/participants", async (c) => {
   const id = c.req.param("id");
   const user = c.get("user");
-  if (!await isParticipantOrOwner(id, user.id)) {
+  if (user.id !== 0 && !await isParticipantOrOwner(id, user.id)) {
     return c.json({ error: "Conversation not found" }, 404);
   }
   const participants = await getParticipants(id);
@@ -1764,232 +2218,17 @@ var app5 = new Hono5().get("/:name/conversations", async (c) => {
   if (!deleted) return c.json({ error: "Conversation not found" }, 404);
   return c.json({ ok: true });
 });
-var conversations_default = app5;
-
-// src/web/routes/files.ts
-import { existsSync as existsSync5 } from "fs";
-import { readdir, readFile, writeFile } from "fs/promises";
-import { resolve as resolve7 } from "path";
-import { zValidator as zValidator4 } from "@hono/zod-validator";
-import { Hono as Hono6 } from "hono";
-import { z as z4 } from "zod";
-var ALLOWED_FILES = /* @__PURE__ */ new Set(["SOUL.md", "MEMORY.md", "CLAUDE.md", "VOLUTE.md"]);
-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 = 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);
-}).get("/:name/files/:filename", 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 = 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", zValidator4("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 = resolve7(dir, "home", filename);
-  const { content } = c.req.valid("json");
-  await writeFile(filePath, content);
-  return c.json({ ok: true });
-});
-var files_default = app6;
-
-// src/web/routes/logs.ts
-import { spawn as spawn2 } from "child_process";
-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) => {
-  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 = resolve8(dir, ".volute", "logs", "agent.log");
-  if (!existsSync6(logFile)) {
-    return c.json({ error: "No log file found" }, 404);
-  }
-  return streamSSE2(c, async (stream2) => {
-    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(() => {
-          });
-        }
-      }
-    };
-    tail.stdout.on("data", onData);
-    stream2.onAbort(() => {
-      tail.kill();
-    });
-    await new Promise((resolve11) => {
-      tail.on("exit", resolve11);
-      stream2.onAbort(resolve11);
-    });
-  });
-});
-var logs_default = app7;
-
-// src/web/routes/schedules.ts
-import { Hono as Hono8 } from "hono";
-function readSchedules(name) {
-  return readVoluteConfig(agentDir(name))?.schedules ?? [];
-}
-function writeSchedules(name, schedules) {
-  const dir = agentDir(name);
-  const config = readVoluteConfig(dir) ?? {};
-  config.schedules = schedules.length > 0 ? schedules : void 0;
-  writeVoluteConfig(dir, config);
-  getScheduler().loadSchedules(name);
-}
-var app8 = new Hono8().get("/:name/schedules", (c) => {
-  const name = c.req.param("name");
-  if (!findAgent(name)) return c.json({ error: "Agent not found" }, 404);
-  return c.json(readSchedules(name));
-}).post("/:name/schedules", requireAdmin, async (c) => {
-  const name = c.req.param("name");
-  if (!findAgent(name)) return c.json({ error: "Agent not found" }, 404);
-  const body = await c.req.json();
-  if (!body.cron || !body.message) {
-    return c.json({ error: "cron and message are required" }, 400);
-  }
-  const schedules = readSchedules(name);
-  const id = body.id || `schedule-${Date.now()}`;
-  if (schedules.some((s) => s.id === id)) {
-    return c.json({ error: `Schedule "${id}" already exists` }, 409);
-  }
-  schedules.push({ id, cron: body.cron, message: body.message, enabled: body.enabled ?? true });
-  writeSchedules(name, schedules);
-  return c.json({ ok: true, id }, 201);
-}).put("/:name/schedules/:id", requireAdmin, async (c) => {
-  const name = c.req.param("name");
-  const id = c.req.param("id");
-  if (!findAgent(name)) return c.json({ error: "Agent not found" }, 404);
-  const schedules = readSchedules(name);
-  const idx = schedules.findIndex((s) => s.id === id);
-  if (idx === -1) return c.json({ error: "Schedule not found" }, 404);
-  const body = await c.req.json();
-  if (body.cron !== void 0) schedules[idx].cron = body.cron;
-  if (body.message !== void 0) schedules[idx].message = body.message;
-  if (body.enabled !== void 0) schedules[idx].enabled = body.enabled;
-  writeSchedules(name, schedules);
-  return c.json({ ok: true });
-}).delete("/:name/schedules/:id", requireAdmin, (c) => {
-  const name = c.req.param("name");
-  const id = c.req.param("id");
-  if (!findAgent(name)) return c.json({ error: "Agent not found" }, 404);
-  const schedules = readSchedules(name);
-  const filtered = schedules.filter((s) => s.id !== id);
-  if (filtered.length === schedules.length) {
-    return c.json({ error: "Schedule not found" }, 404);
-  }
-  writeSchedules(name, filtered);
-  return c.json({ ok: true });
-}).post("/:name/webhook/:event", async (c) => {
-  const name = c.req.param("name");
-  const event = c.req.param("event");
-  const entry = findAgent(name);
-  if (!entry) return c.json({ error: "Agent not found" }, 404);
-  const body = await c.req.text();
-  const message = `[webhook: ${event}] ${body}`;
-  try {
-    const res = await fetch(`http://127.0.0.1:${entry.port}/message`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        content: [{ type: "text", text: message }],
-        channel: "system:webhook",
-        sender: "webhook"
-      })
-    });
-    if (!res.ok) {
-      return c.json({ error: `Agent responded with ${res.status}` }, 502);
-    }
-    return c.json({ ok: true });
-  } catch {
-    return c.json({ error: "Failed to reach agent" }, 502);
-  }
-});
-var schedules_default = app8;
-
-// src/web/routes/system.ts
-import { Hono as Hono9 } from "hono";
-import { streamSSE as streamSSE3 } from "hono/streaming";
-var app9 = new Hono9().get("/logs", async (c) => {
-  const user = c.get("user");
-  if (user.role !== "admin") return c.json({ error: "Forbidden" }, 403);
-  return streamSSE3(c, async (stream2) => {
-    for (const entry of logBuffer.getEntries()) {
-      await stream2.writeSSE({ data: JSON.stringify(entry) });
-    }
-    const unsubscribe = logBuffer.subscribe((entry) => {
-      stream2.writeSSE({ data: JSON.stringify(entry) }).catch(() => {
-      });
-    });
-    await new Promise((resolve11) => {
-      stream2.onAbort(() => {
-        unsubscribe();
-        resolve11();
-      });
-    });
-  });
-});
-var system_default = app9;
-
-// src/web/routes/update.ts
-import { spawn as spawn3 } from "child_process";
-import { Hono as Hono10 } from "hono";
-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;
+var conversations_default = app12;
 
-// 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)
+// src/web/routes/volute/user-conversations.ts
+import { zValidator as zValidator6 } 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)
 });
-var app11 = new Hono11().use("*", authMiddleware).get("/", async (c) => {
+var app13 = new Hono13().use("*", authMiddleware).get("/", async (c) => {
   const user = c.get("user");
   const convs = await listConversationsWithParticipants(user.id);
   return c.json(convs);
@@ -2001,7 +2240,7 @@ var app11 = new Hono11().use("*", authMiddleware).get("/", async (c) => {
   }
   const msgs = await getMessages(id);
   return c.json(msgs);
-}).post("/", zValidator5("json", createSchema), async (c) => {
+}).post("/", zValidator6("json", createSchema), async (c) => {
   const user = c.get("user");
   const body = c.req.valid("json");
   const participantIds = /* @__PURE__ */ new Set();
@@ -2038,29 +2277,11 @@ var app11 = new Hono11().use("*", authMiddleware).get("/", async (c) => {
   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);
-  const variants = readVariants(name);
-  const results = await Promise.all(
-    variants.map(async (v) => {
-      if (!v.port) return { ...v, status: "no-server" };
-      const health = await checkHealth(v.port);
-      return { ...v, status: health.ok ? "running" : "dead" };
-    })
-  );
-  return c.json(results);
-});
-var variants_default = app12;
+var user_conversations_default = app13;
 
 // src/web/app.ts
-var app13 = new Hono13();
-app13.onError((err, c) => {
+var app14 = new Hono14();
+app14.onError((err, c) => {
   if (err instanceof HTTPException) {
     return err.getResponse();
   }
@@ -2071,10 +2292,10 @@ app13.onError((err, c) => {
   });
   return c.json({ error: "Internal server error" }, 500);
 });
-app13.notFound((c) => {
+app14.notFound((c) => {
   return c.json({ error: "Not found" }, 404);
 });
-app13.use("*", async (c, next) => {
+app14.use("*", async (c, next) => {
   const start = Date.now();
   await next();
   const duration = Date.now() - start;
@@ -2085,7 +2306,7 @@ app13.use("*", async (c, next) => {
     duration
   });
 });
-app13.get("/api/health", (c) => {
+app14.get("/api/health", (c) => {
   let version = "unknown";
   let cached = null;
   try {
@@ -2100,13 +2321,13 @@ app13.get("/api/health", (c) => {
     ...cached?.updateAvailable ? { updateAvailable: true, latest: cached.latest } : {}
   });
 });
-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;
+app14.use("/api/*", bodyLimit({ maxSize: 10 * 1024 * 1024 }));
+app14.use("/api/*", csrf());
+app14.use("/api/agents/*", authMiddleware);
+app14.use("/api/conversations/*", authMiddleware);
+app14.use("/api/system/*", authMiddleware);
+var routes = app14.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", typing_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 = app14;
 
 // src/web/server.ts
 var MIME_TYPES = {
@@ -2123,20 +2344,20 @@ 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)) {
+    const candidate = resolve8(searchDir, "dist", "web-assets");
+    if (existsSync6(candidate)) {
       assetsDir = candidate;
       break;
     }
-    searchDir = dirname3(searchDir);
+    searchDir = dirname2(searchDir);
   }
   if (assetsDir) {
     app_default.get("*", async (c) => {
       const urlPath = new URL(c.req.url).pathname;
       if (urlPath.startsWith("/api/")) return c.notFound();
-      const filePath = resolve9(assetsDir, urlPath.slice(1));
+      const filePath = resolve8(assetsDir, urlPath.slice(1));
       if (!filePath.startsWith(assetsDir)) return c.text("Forbidden", 403);
       const s = await stat(filePath).catch(() => null);
       if (s?.isFile()) {
@@ -2145,7 +2366,7 @@ async function startServer({
         const body = await readFile2(filePath);
         return c.body(body, 200, { "Content-Type": mime });
       }
-      const indexPath = resolve9(assetsDir, "index.html");
+      const indexPath = resolve8(assetsDir, "index.html");
       const indexStat = await stat(indexPath).catch(() => null);
       if (indexStat?.isFile()) {
         const body = await readFile2(indexPath, "utf-8");
@@ -2155,10 +2376,10 @@ async function startServer({
     });
   }
   const server = serve({ fetch: app_default.fetch, port, hostname });
-  await new Promise((resolve11, reject) => {
+  await new Promise((resolve10, reject) => {
     server.on("listening", () => {
       logger_default.info("Volute UI running", { hostname, port });
-      resolve11();
+      resolve10();
     });
     server.on("error", (err) => {
       reject(err);
@@ -2169,14 +2390,14 @@ async function startServer({
 
 // src/daemon.ts
 if (!process.env.VOLUTE_HOME) {
-  process.env.VOLUTE_HOME = resolve10(homedir(), ".volute");
+  process.env.VOLUTE_HOME = resolve9(homedir(), ".volute");
 }
 async function startDaemon(opts) {
   const { port, hostname } = opts;
   const myPid = String(process.pid);
   const home = voluteHome();
   if (!opts.foreground) {
-    const log2 = new RotatingLog(resolve10(home, "daemon.log"));
+    const log2 = new RotatingLog(resolve9(home, "daemon.log"));
     const write2 = (...args) => log2.write(`${format(...args)}
 `);
     console.log = write2;
@@ -2184,11 +2405,12 @@ async function startDaemon(opts) {
     console.warn = write2;
     console.info = write2;
   }
-  const DAEMON_PID_PATH = resolve10(home, "daemon.pid");
-  const DAEMON_JSON_PATH = resolve10(home, "daemon.json");
+  const DAEMON_PID_PATH = resolve9(home, "daemon.pid");
+  const DAEMON_JSON_PATH = resolve9(home, "daemon.json");
   mkdirSync2(home, { recursive: true });
   const token = process.env.VOLUTE_DAEMON_TOKEN || randomBytes(32).toString("hex");
   process.env.VOLUTE_DAEMON_TOKEN = token;
+  process.env.VOLUTE_DAEMON_HOSTNAME = hostname;
   let server;
   try {
     server = await startServer({ port, hostname });
@@ -2210,6 +2432,8 @@ async function startDaemon(opts) {
   const connectors = initConnectorManager();
   const scheduler = getScheduler();
   scheduler.start(port, token);
+  const tokenBudget = getTokenBudget();
+  tokenBudget.start(port, token);
   const registry = readRegistry();
   for (const entry of registry) {
     if (!entry.running) continue;
@@ -2218,6 +2442,14 @@ async function startDaemon(opts) {
       const dir = agentDir(entry.name);
       await connectors.startConnectors(entry.name, dir, entry.port, port);
       scheduler.loadSchedules(entry.name);
+      const config = readVoluteConfig(dir);
+      if (config?.tokenBudget) {
+        tokenBudget.setBudget(
+          entry.name,
+          config.tokenBudget,
+          config.tokenBudgetPeriodMinutes ?? DEFAULT_BUDGET_PERIOD_MINUTES
+        );
+      }
     } catch (err) {
       console.error(`[daemon] failed to start agent ${entry.name}:`, err);
       setAgentRunning(entry.name, false);
@@ -2258,6 +2490,7 @@ async function startDaemon(opts) {
     console.error("[daemon] shutting down...");
     scheduler.stop();
     scheduler.saveState();
+    tokenBudget.stop();
     await connectors.stopAll();
     await manager.stopAll();
     manager.clearCrashAttempts();