volute 0.4.0 → 0.6.0

package/dist/daemon.js

@@ -1,33 +1,41 @@
 #!/usr/bin/env node
 import {
-  CHANNELS
-} from "./chunk-5OCWMTVS.js";
-import {
+  RotatingLog,
   clearJsonMap,
   getAgentManager,
   initAgentManager,
   loadJsonMap,
   saveJsonMap
-} from "./chunk-I6OHXCMV.js";
+} from "./chunk-G6ZNGLUX.js";
+import {
+  checkForUpdate,
+  checkForUpdateCached,
+  getCurrentVersion
+} from "./chunk-AOKAQGO4.js";
+import {
+  collectPart
+} from "./chunk-B3R6L2GW.js";
 import {
-  collectPart,
-  logBuffer,
-  logger_default,
-  readNdjson
-} from "./chunk-ZHCE4DPY.js";
+  CHANNELS
+} from "./chunk-ZZOOTYXK.js";
 import {
   readVoluteConfig,
   writeVoluteConfig
 } from "./chunk-NETNFBA5.js";
 import {
   loadMergedEnv
-} from "./chunk-DNOXHLE5.js";
+} from "./chunk-H7AMDUIA.js";
+import "./chunk-BX7KI4S3.js";
 import {
   applyIsolation
-} from "./chunk-SOZA2TLP.js";
+} from "./chunk-W76KWE23.js";
+import {
+  resolveVoluteBin
+} from "./chunk-5SKQ6J7T.js";
 import {
   agentDir,
   checkHealth,
+  daemonLoopback,
   findAgent,
   findVariant,
   getAllRunningVariants,
@@ -38,26 +46,21 @@ import {
   setAgentRunning,
   setVariantRunning,
   voluteHome
-} from "./chunk-3C2XR4IY.js";
+} from "./chunk-UWHWAPGO.js";
 import {
   __export
 } from "./chunk-K3NQKI34.js";
 
 // src/daemon.ts
 import { randomBytes } from "crypto";
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve9 } from "path";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir } from "os";
+import { resolve as resolve10 } from "path";
+import { format } from "util";
 
 // src/lib/connector-manager.ts
 import { spawn } from "child_process";
-import {
-  createWriteStream,
-  existsSync as existsSync2,
-  mkdirSync,
-  readFileSync as readFileSync2,
-  unlinkSync,
-  writeFileSync
-} from "fs";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
 import { dirname, resolve as resolve2 } from "path";
 
 // src/lib/connector-defs.ts
@@ -217,7 +220,7 @@ var ConnectorManager = class {
     }
     const logsDir = resolve2(agentDir2, ".volute", "logs");
     mkdirSync(logsDir, { recursive: true });
-    const logStream = createWriteStream(resolve2(logsDir, `${type}.log`), { flags: "a" });
+    const logStream = new RotatingLog(resolve2(logsDir, `${type}.log`));
     const agentEnv = loadMergedEnv(agentDir2);
     const prefix = `${type.toUpperCase()}_`;
     const connectorEnv = Object.fromEntries(
@@ -231,7 +234,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
@@ -292,19 +295,19 @@ var ConnectorManager = class {
     const stopKey = `${agentName}:${type}`;
     this.stopping.add(stopKey);
     agentMap.delete(type);
-    await new Promise((resolve10) => {
-      tracked.child.on("exit", () => resolve10());
+    await new Promise((resolve11) => {
+      tracked.child.on("exit", () => resolve11());
       try {
         tracked.child.kill("SIGTERM");
       } catch {
-        resolve10();
+        resolve11();
       }
       setTimeout(() => {
         try {
           tracked.child.kill("SIGKILL");
         } catch {
         }
-        resolve10();
+        resolve11();
       }, 5e3);
     });
     this.stopping.delete(stopKey);
@@ -477,7 +480,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: {
@@ -502,7 +505,15 @@ var Scheduler = class {
         console.error(`[scheduler] fired "${schedule.id}" for ${agentName}`);
       }
       try {
-        await res.body?.cancel();
+        const reader = res.body?.getReader();
+        if (reader) {
+          try {
+            while (!(await reader.read()).done) {
+            }
+          } finally {
+            reader.releaseLock();
+          }
+        }
       } catch {
       }
     } catch (err) {
@@ -518,6 +529,180 @@ function getScheduler() {
   return instance2;
 }
 
+// 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);
+  }
+  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:
+
+${summary}`
+        }
+      ],
+      channel: "system:budget-replay",
+      sender: "system"
+    });
+    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);
+    }
+  }
+};
+var instance3 = null;
+function getTokenBudget() {
+  if (!instance3) instance3 = new TokenBudget();
+  return instance3;
+}
+
 // src/web/middleware/auth.ts
 import { timingSafeEqual } from "crypto";
 import { eq as eq2, lt } from "drizzle-orm";
@@ -539,18 +724,20 @@ import { migrate } from "drizzle-orm/libsql/migrator";
 var schema_exports = {};
 __export(schema_exports, {
   agentMessages: () => agentMessages,
+  conversationParticipants: () => conversationParticipants,
   conversations: () => conversations,
   messages: () => messages,
   sessions: () => sessions,
   users: () => users
 });
 import { sql } from "drizzle-orm";
-import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
 var users = sqliteTable("users", {
   id: integer("id").primaryKey({ autoIncrement: true }),
   username: text("username").unique().notNull(),
   password_hash: text("password_hash").notNull(),
   role: text("role").notNull().default("pending"),
+  user_type: text("user_type").notNull().default("human"),
   created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
 });
 var conversations = sqliteTable(
@@ -586,6 +773,19 @@ var agentMessages = sqliteTable(
     index("idx_agent_messages_channel").on(table.agent, table.channel)
   ]
 );
+var conversationParticipants = sqliteTable(
+  "conversation_participants",
+  {
+    conversation_id: text("conversation_id").notNull().references(() => conversations.id, { onDelete: "cascade" }),
+    user_id: integer("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    role: text("role").notNull().default("member"),
+    joined_at: text("joined_at").notNull().default(sql`(datetime('now'))`)
+  },
+  (table) => [
+    uniqueIndex("idx_cp_unique").on(table.conversation_id, table.user_id),
+    index("idx_cp_user_id").on(table.user_id)
+  ]
+);
 var sessions = sqliteTable("sessions", {
   id: text("id").primaryKey(),
   userId: integer("user_id").references(() => users.id, { onDelete: "cascade" }).notNull(),
@@ -628,12 +828,13 @@ async function getDb() {
 async function createUser(username, password) {
   const db2 = await getDb();
   const hash = hashSync(password, 10);
-  const [{ value }] = await db2.select({ value: count() }).from(users);
+  const [{ value }] = await db2.select({ value: count() }).from(users).where(eq(users.user_type, "human"));
   const role = value === 0 ? "admin" : "pending";
   const [result] = await db2.insert(users).values({ username, password_hash: hash, role }).returning({
     id: users.id,
     username: users.username,
     role: users.role,
+    user_type: users.user_type,
     created_at: users.created_at
   });
   return result;
@@ -642,6 +843,7 @@ async function verifyUser(username, password) {
   const db2 = await getDb();
   const row = await db2.select().from(users).where(eq(users.username, username)).get();
   if (!row) return null;
+  if (row.user_type === "agent") return null;
   if (!compareSync(password, row.password_hash)) return null;
   const { password_hash: _, ...user } = row;
   return user;
@@ -652,6 +854,7 @@ async function getUser(id) {
     id: users.id,
     username: users.username,
     role: users.role,
+    user_type: users.user_type,
     created_at: users.created_at
   }).from(users).where(eq(users.id, id)).get();
   return row ?? null;
@@ -662,6 +865,7 @@ async function getUserByUsername(username) {
     id: users.id,
     username: users.username,
     role: users.role,
+    user_type: users.user_type,
     created_at: users.created_at
   }).from(users).where(eq(users.username, username)).get();
   return row ?? null;
@@ -672,6 +876,7 @@ async function listUsers() {
     id: users.id,
     username: users.username,
     role: users.role,
+    user_type: users.user_type,
     created_at: users.created_at
   }).from(users).orderBy(users.created_at).all();
 }
@@ -681,9 +886,58 @@ async function listPendingUsers() {
     id: users.id,
     username: users.username,
     role: users.role,
+    user_type: users.user_type,
     created_at: users.created_at
   }).from(users).where(eq(users.role, "pending")).orderBy(users.created_at).all();
 }
+async function listUsersByType(userType) {
+  const db2 = await getDb();
+  return db2.select({
+    id: users.id,
+    username: users.username,
+    role: users.role,
+    user_type: users.user_type,
+    created_at: users.created_at
+  }).from(users).where(eq(users.user_type, userType)).orderBy(users.created_at).all();
+}
+async function getOrCreateAgentUser(agentName) {
+  const db2 = await getDb();
+  const existing = await db2.select({
+    id: users.id,
+    username: users.username,
+    role: users.role,
+    user_type: users.user_type,
+    created_at: users.created_at
+  }).from(users).where(and(eq(users.username, agentName), eq(users.user_type, "agent"))).get();
+  if (existing) return existing;
+  try {
+    const [result] = await db2.insert(users).values({
+      username: agentName,
+      password_hash: "!agent",
+      role: "agent",
+      user_type: "agent"
+    }).returning({
+      id: users.id,
+      username: users.username,
+      role: users.role,
+      user_type: users.user_type,
+      created_at: users.created_at
+    });
+    return result;
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
+      const retried = await db2.select({
+        id: users.id,
+        username: users.username,
+        role: users.role,
+        user_type: users.user_type,
+        created_at: users.created_at
+      }).from(users).where(and(eq(users.username, agentName), eq(users.user_type, "agent"))).get();
+      if (retried) return retried;
+    }
+    throw err;
+  }
+}
 async function approveUser(id) {
   const db2 = await getDb();
   await db2.update(users).set({ role: "user" }).where(and(eq(users.id, id), eq(users.role, "pending")));
@@ -733,7 +987,7 @@ var authMiddleware = createMiddleware(async (c, next) => {
   if (authHeader?.startsWith("Bearer ")) {
     const token = authHeader.slice(7);
     if (token && isValidDaemonToken(token)) {
-      c.set("user", { id: 0, username: "cli", role: "admin" });
+      c.set("user", { id: 0, username: "cli", role: "admin", user_type: "human" });
       await next();
       return;
     }
@@ -752,11 +1006,55 @@ 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 resolve8 } from "path";
+import { dirname as dirname3, extname, resolve as resolve9 } from "path";
 import { serve } from "@hono/node-server";
 
+// src/lib/log-buffer.ts
+var LogBuffer = class {
+  entries = [];
+  maxSize = 1e3;
+  subscribers = /* @__PURE__ */ new Set();
+  append(entry) {
+    this.entries.push(entry);
+    if (this.entries.length > this.maxSize) {
+      this.entries.shift();
+    }
+    for (const sub of this.subscribers) {
+      sub(entry);
+    }
+  }
+  getEntries() {
+    return [...this.entries];
+  }
+  subscribe(fn) {
+    this.subscribers.add(fn);
+    return () => this.subscribers.delete(fn);
+  }
+};
+var logBuffer = new LogBuffer();
+
+// src/lib/logger.ts
+function write(level, msg, data) {
+  const entry = {
+    level,
+    msg,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    ...data ? { data } : {}
+  };
+  const line = JSON.stringify(entry);
+  process.stderr.write(`${line}
+`);
+  logBuffer.append(entry);
+}
+var log = {
+  info: (msg, data) => write("info", msg, data),
+  warn: (msg, data) => write("warn", msg, data),
+  error: (msg, data) => write("error", msg, data)
+};
+var logger_default = log;
+
 // src/web/app.ts
-import { Hono as Hono11 } from "hono";
+import { Hono as Hono14 } from "hono";
 import { bodyLimit } from "hono/body-limit";
 import { csrf } from "hono/csrf";
 import { HTTPException } from "hono/http-exception";
@@ -767,6 +1065,114 @@ import { resolve as resolve5 } from "path";
 import { and as and2, desc, eq as eq3 } from "drizzle-orm";
 import { Hono } from "hono";
 import { stream } from "hono/streaming";
+
+// src/lib/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;
+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"));
@@ -782,21 +1188,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.web.name,
-    displayName: CHANNELS.web.displayName,
-    status: status === "running" ? "connected" : "disconnected",
-    showToolCalls: CHANNELS.web.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 };
@@ -852,6 +1262,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) {
@@ -873,7 +1291,10 @@ var app = new Hono().get("/", async (c) => {
   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);
@@ -881,6 +1302,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) {
@@ -903,6 +1332,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 });
@@ -918,6 +1348,7 @@ 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);
@@ -971,12 +1402,61 @@ var app = new Hono().get("/", async (c) => {
       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 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);
@@ -990,33 +1470,76 @@ 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 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);
+  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 db2 = await getDb();
+  try {
+    await db2.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();
@@ -1049,6 +1572,14 @@ var credentialsSchema = z.object({
 var admin = new Hono2().use(authMiddleware).get("/users", async (c) => {
   const user = c.get("user");
   if (user.role !== "admin") return c.json({ error: "Forbidden" }, 403);
+  const agents = readRegistry();
+  for (const agent of agents) {
+    await getOrCreateAgentUser(agent.name);
+  }
+  const type = c.req.query("type");
+  if (type === "human" || type === "agent") {
+    return c.json(await listUsersByType(type));
+  }
   return c.json(await listUsers());
 }).get("/users/pending", async (c) => {
   const user = c.get("user");
@@ -1100,254 +1631,28 @@ var app2 = new Hono2().post("/register", zValidator("json", credentialsSchema),
 }).route("/", admin);
 var auth_default = app2;
 
-// src/web/routes/chat.ts
-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, 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 };
   });
-  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 getConversationForUser(id, userId) {
-  const db2 = await getDb();
-  const row = await db2.select().from(conversations).where(and3(eq4(conversations.id, id), eq4(conversations.user_id, userId))).get();
-  return row ?? null;
-}
-async function deleteConversationForUser(id, userId) {
-  const conv = await getConversationForUser(id, userId);
-  if (!conv) return false;
-  await deleteConversation(id);
-  return true;
-}
-async function listConversations(agentName, opts) {
-  const db2 = await getDb();
-  if (opts?.userId != null) {
-    return db2.select().from(conversations).where(and3(eq4(conversations.agent_name, agentName), eq4(conversations.user_id, opts.userId))).orderBy(desc2(conversations.updated_at)).all();
-  }
-  return db2.select().from(conversations).where(eq4(conversations.agent_name, agentName)).orderBy(desc2(conversations.updated_at)).all();
-}
-async function addMessage(conversationId, role, senderName, content) {
-  const db2 = await getDb();
-  const serialized = JSON.stringify(content);
-  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));
-  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)));
-    }
-  }
-  return {
-    id: result.id,
-    conversation_id: conversationId,
-    role,
-    sender_name: senderName,
-    content,
-    created_at: result.created_at
-  };
-}
-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();
-  return rows.map((row) => {
-    let content;
-    try {
-      const parsed = JSON.parse(row.content);
-      content = Array.isArray(parsed) ? parsed : [{ type: "text", text: row.content }];
-    } catch {
-      content = [{ type: "text", text: row.content }];
-    }
-    return { ...row, content };
-  });
-}
-async function deleteConversation(id) {
-  const db2 = await getDb();
-  await db2.delete(conversations).where(eq4(conversations.id, id));
-}
-
-// src/web/routes/chat.ts
-var chatSchema = z2.object({
-  message: z2.string().optional(),
-  conversationId: z2.string().optional(),
-  images: z2.array(
-    z2.object({
-      media_type: z2.string(),
-      data: z2.string()
-    })
-  ).optional()
-});
-var app3 = new Hono3().post("/:name/chat", zValidator2("json", chatSchema), async (c) => {
-  const name = c.req.param("name");
-  const [baseName, variantName] = name.split("@", 2);
-  const entry = findAgent(baseName);
-  if (!entry) return c.json({ error: "Agent not found" }, 404);
-  let port = entry.port;
-  if (variantName) {
-    const variant = findVariant(baseName, variantName);
-    if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
-    port = variant.port;
-  }
-  const { getAgentManager: getAgentManager2 } = await import("./agent-manager-AUCKMGPR.js");
-  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);
-  }
-  const user = c.get("user");
-  let conversationId = body.conversationId;
-  if (conversationId) {
-    const conv = await getConversationForUser(conversationId, user.id);
-    if (!conv) return c.json({ error: "Conversation not found" }, 404);
-  } else {
-    const title = body.message ? body.message.slice(0, 80) : "Image message";
-    const conv = await createConversation(baseName, "web", {
-      userId: user.id,
-      title
-    });
-    conversationId = conv.id;
-  }
-  const contentBlocks = [];
-  if (body.message) {
-    contentBlocks.push({ type: "text", text: body.message });
-  }
-  if (body.images) {
-    for (const img of body.images) {
-      contentBlocks.push({ type: "image", media_type: img.media_type, data: img.data });
-    }
-  }
-  await addMessage(conversationId, "user", user.username, contentBlocks);
-  const db2 = await getDb();
-  await db2.insert(agentMessages).values({
-    agent: baseName,
-    channel: "web",
-    role: "user",
-    sender: user.username,
-    content: body.message ?? "[image]"
-  });
-  let res;
-  try {
-    res = await fetch(`http://127.0.0.1:${port}/message`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        content: contentBlocks,
-        channel: "web",
-        sender: user.username
-      })
-    });
-  } catch (err) {
-    console.error(`[chat] agent ${name} unreachable on port ${port}:`, err);
-    return c.json({ error: "Agent is not reachable" }, 502);
-  }
-  if (!res.ok) {
-    return c.json({ error: `Agent responded with ${res.status}` }, res.status);
-  }
-  if (!res.body) {
-    return c.json({ error: "No response body from agent" }, 502);
-  }
-  return streamSSE(c, async (stream2) => {
-    await stream2.writeSSE({
-      data: JSON.stringify({ type: "meta", conversationId })
-    });
-    const assistantContent = [];
-    for await (const event of readNdjson(res.body)) {
-      await stream2.writeSSE({ data: JSON.stringify(event) });
-      if (event.type === "text") {
-        const last = assistantContent[assistantContent.length - 1];
-        if (last && last.type === "text") {
-          last.text += event.content;
-        } else {
-          assistantContent.push({ type: "text", text: event.content });
-        }
-      } else if (event.type === "tool_use") {
-        assistantContent.push({
-          type: "tool_use",
-          name: event.name,
-          input: event.input
-        });
-      } else if (event.type === "tool_result") {
-        assistantContent.push({
-          type: "tool_result",
-          output: event.output,
-          ...event.is_error ? { is_error: true } : {}
-        });
-      }
-      if (event.type === "done") {
-        if (assistantContent.length > 0) {
-          await addMessage(conversationId, "assistant", baseName, assistantContent);
-          const textParts = [];
-          const toolParts = [];
-          for (const b of assistantContent) {
-            const part = collectPart(b);
-            if (part != null) {
-              if (b.type === "tool_use") toolParts.push(part);
-              else textParts.push(part);
-            }
-          }
-          const summary = [textParts.join(""), ...toolParts].filter(Boolean).join("\n");
-          if (summary) {
-            await db2.insert(agentMessages).values({
-              agent: baseName,
-              channel: "web",
-              role: "assistant",
-              sender: baseName,
-              content: summary
-            });
-          }
-        }
-        break;
-      }
-    }
-  });
-});
-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);
+  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);
@@ -1395,41 +1700,18 @@ var app4 = new Hono4().get("/:name/connectors", (c) => {
   writeVoluteConfig(dir, config);
   return c.json({ ok: true });
 });
-var connectors_default = app4;
-
-// src/web/routes/conversations.ts
-import { Hono as Hono5 } from "hono";
-var app5 = new Hono5().get("/:name/conversations", async (c) => {
-  const name = c.req.param("name");
-  const user = c.get("user");
-  const convs = await listConversations(name, { userId: user.id });
-  return c.json(convs);
-}).get("/:name/conversations/:id/messages", async (c) => {
-  const id = c.req.param("id");
-  const user = c.get("user");
-  const conv = await getConversationForUser(id, user.id);
-  if (!conv) return c.json({ error: "Conversation not found" }, 404);
-  const msgs = await getMessages(id);
-  return c.json(msgs);
-}).delete("/:name/conversations/:id", async (c) => {
-  const id = c.req.param("id");
-  const user = c.get("user");
-  const deleted = await deleteConversationForUser(id, user.id);
-  if (!deleted) return c.json({ error: "Conversation not found" }, 404);
-  return c.json({ ok: true });
-});
-var conversations_default = app5;
+var connectors_default = app3;
 
 // src/web/routes/files.ts
 import { existsSync as existsSync5 } from "fs";
 import { readdir, readFile, writeFile } from "fs/promises";
 import { resolve as resolve6 } from "path";
-import { zValidator as zValidator3 } from "@hono/zod-validator";
-import { Hono as Hono6 } from "hono";
-import { z as z3 } from "zod";
+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 = z3.object({ content: z3.string() });
-var app6 = new Hono6().get("/:name/files", async (c) => {
+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);
@@ -1454,7 +1736,7 @@ var app6 = new Hono6().get("/:name/files", async (c) => {
   }
   const content = await readFile(filePath, "utf-8");
   return c.json({ filename, content });
-}).put("/:name/files/:filename", zValidator3("json", saveFileSchema), async (c) => {
+}).put("/:name/files/:filename", zValidator2("json", saveFileSchema), async (c) => {
   const name = c.req.param("name");
   const filename = c.req.param("filename");
   if (!ALLOWED_FILES.has(filename)) {
@@ -1468,15 +1750,15 @@ var app6 = new Hono6().get("/:name/files", async (c) => {
   await writeFile(filePath, content);
   return c.json({ ok: true });
 });
-var files_default = app6;
+var files_default = app4;
 
 // src/web/routes/logs.ts
 import { spawn as spawn2 } from "child_process";
 import { existsSync as existsSync6 } from "fs";
 import { resolve as resolve7 } from "path";
-import { Hono as Hono7 } from "hono";
-import { streamSSE as streamSSE2 } from "hono/streaming";
-var app7 = new Hono7().get("/:name/logs", async (c) => {
+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);
@@ -1485,7 +1767,7 @@ var app7 = new Hono7().get("/:name/logs", async (c) => {
   if (!existsSync6(logFile)) {
     return c.json({ error: "No log file found" }, 404);
   }
-  return streamSSE2(c, async (stream2) => {
+  return streamSSE(c, async (stream2) => {
     const tail = spawn2("tail", ["-n", "200", "-f", logFile]);
     const onData = (data) => {
       const lines = data.toString().split("\n");
@@ -1500,16 +1782,16 @@ var app7 = new Hono7().get("/:name/logs", async (c) => {
     stream2.onAbort(() => {
       tail.kill();
     });
-    await new Promise((resolve10) => {
-      tail.on("exit", resolve10);
-      stream2.onAbort(resolve10);
+    await new Promise((resolve11) => {
+      tail.on("exit", resolve11);
+      stream2.onAbort(resolve11);
     });
   });
 });
-var logs_default = app7;
+var logs_default = app5;
 
 // src/web/routes/schedules.ts
-import { Hono as Hono8 } from "hono";
+import { Hono as Hono6 } from "hono";
 function readSchedules(name) {
   return readVoluteConfig(agentDir(name))?.schedules ?? [];
 }
@@ -1520,7 +1802,7 @@ function writeSchedules(name, schedules) {
   writeVoluteConfig(dir, config);
   getScheduler().loadSchedules(name);
 }
-var app8 = new Hono8().get("/:name/schedules", (c) => {
+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));
@@ -1588,15 +1870,15 @@ var app8 = new Hono8().get("/:name/schedules", (c) => {
     return c.json({ error: "Failed to reach agent" }, 502);
   }
 });
-var schedules_default = app8;
+var schedules_default = app6;
 
 // 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) => {
+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 streamSSE3(c, async (stream2) => {
+  return streamSSE2(c, async (stream2) => {
     for (const entry of logBuffer.getEntries()) {
       await stream2.writeSSE({ data: JSON.stringify(entry) });
     }
@@ -1604,15 +1886,64 @@ var app9 = new Hono9().get("/logs", async (c) => {
       stream2.writeSSE({ data: JSON.stringify(entry) }).catch(() => {
       });
     });
-    await new Promise((resolve10) => {
+    await new Promise((resolve11) => {
       stream2.onAbort(() => {
         unsubscribe();
-        resolve10();
+        resolve11();
       });
     });
   });
 });
-var system_default = app9;
+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";
@@ -1632,9 +1963,529 @@ var app10 = new Hono10().get("/:name/variants", async (c) => {
 });
 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 { 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 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
+  });
+  if (opts?.participantIds && opts.participantIds.length > 0) {
+    await db2.insert(conversationParticipants).values(
+      opts.participantIds.map((uid, i) => ({
+        conversation_id: id,
+        user_id: uid,
+        role: i === 0 ? "owner" : "member"
+      }))
+    );
+  }
+  return {
+    id,
+    agent_name: agentName,
+    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 db2 = await getDb();
+  const row = await db2.select().from(conversations).where(eq4(conversations.id, id)).get();
+  return row ?? null;
+}
+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) {
+  if (!await isParticipantOrOwner(id, userId)) return false;
+  await deleteConversation(id);
+  return true;
+}
+async function addMessage(conversationId, role, senderName, content) {
+  const db2 = 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));
+  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)));
+    }
+  }
+  return {
+    id: result.id,
+    conversation_id: conversationId,
+    role,
+    sender_name: senderName,
+    content,
+    created_at: result.created_at
+  };
+}
+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();
+  return rows.map((row) => {
+    let content;
+    try {
+      const parsed = JSON.parse(row.content);
+      content = Array.isArray(parsed) ? parsed : [{ type: "text", text: row.content }];
+    } catch {
+      content = [{ type: "text", text: row.content }];
+    }
+    return { ...row, content };
+  });
+}
+async function listConversationsWithParticipants(userId) {
+  const convs = await listConversationsForUser(userId);
+  if (convs.length === 0) return [];
+  const db2 = await getDb();
+  const convIds = convs.map((c) => c.id);
+  const rows = await db2.select({
+    conversationId: conversationParticipants.conversation_id,
+    userId: users.id,
+    username: users.username,
+    userType: users.user_type,
+    role: conversationParticipants.role
+  }).from(conversationParticipants).innerJoin(users, eq4(conversationParticipants.user_id, users.id)).where(inArray(conversationParticipants.conversation_id, convIds));
+  const byConv = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    let arr = byConv.get(r.conversationId);
+    if (!arr) {
+      arr = [];
+      byConv.set(r.conversationId, arr);
+    }
+    arr.push({
+      userId: r.userId,
+      username: r.username,
+      userType: r.userType,
+      role: r.role
+    });
+  }
+  return convs.map((c) => ({ ...c, participants: byConv.get(c.id) ?? [] }));
+}
+async function findDMConversation(agentName, participantIds) {
+  const db2 = await getDb();
+  const agentConvs = await db2.select({ id: conversations.id }).from(conversations).where(eq4(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();
+    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));
+}
+
+// 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(resolve8(voluteHome(), "daemon.json"), "utf-8"));
+  return `http://${daemonLoopback()}:${data.port}`;
+}
+function daemonFetchInternal(path, body) {
+  const daemonUrl = getDaemonUrl();
+  const token = process.env.VOLUTE_DAEMON_TOKEN;
+  const headers = {
+    "Content-Type": "application/json",
+    Origin: daemonUrl
+  };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  return fetch(`${daemonUrl}${path}`, { method: "POST", headers, body });
+}
+function accumulateEvent(content, event) {
+  if (event.type === "text") {
+    const last = content[content.length - 1];
+    if (last && last.type === "text") last.text += event.content;
+    else content.push({ type: "text", text: event.content });
+  } else if (event.type === "tool_use") {
+    content.push({ type: "tool_use", name: event.name, input: event.input });
+  } else if (event.type === "tool_result") {
+    content.push({
+      type: "tool_result",
+      output: event.output,
+      ...event.is_error ? { is_error: true } : {}
+    });
+  }
+}
+async function consumeAndPersist(res, conversationId, agentName) {
+  if (!res.body) {
+    console.warn(`[chat] no response body from ${agentName}`);
+    return [];
+  }
+  const assistantContent = [];
+  for await (const event of readNdjson(res.body)) {
+    accumulateEvent(assistantContent, event);
+    if (event.type === "done") break;
+  }
+  if (assistantContent.length === 0) return [];
+  try {
+    await addMessage(conversationId, "assistant", agentName, assistantContent);
+  } catch (err) {
+    console.error(`[chat] failed to persist conversation message from ${agentName}:`, err);
+  }
+  return assistantContent;
+}
+var 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 body = c.req.valid("json");
+  if (!body.message && (!body.images || body.images.length === 0)) {
+    return c.json({ error: "message or images required" }, 400);
+  }
+  const user = c.get("user");
+  const agentUser = await getOrCreateAgentUser(baseName);
+  const senderName = user.id === 0 && body.sender ? body.sender : user.username;
+  let conversationId = body.conversationId;
+  if (conversationId) {
+    if (user.id !== 0 && !await isParticipantOrOwner(conversationId, user.id)) {
+      return c.json({ error: "Conversation not found" }, 404);
+    }
+  } else {
+    const title = body.message ? body.message.slice(0, 80) : "Image message";
+    const participantIds = [];
+    if (user.id !== 0) {
+      participantIds.push(user.id);
+    } else if (body.sender) {
+      const senderAgent = findAgent(body.sender);
+      if (senderAgent) {
+        const senderAgentUser = await getOrCreateAgentUser(body.sender);
+        participantIds.push(senderAgentUser.id);
+      }
+    }
+    participantIds.push(agentUser.id);
+    if (participantIds.length === 2) {
+      const existing = await findDMConversation(baseName, participantIds);
+      if (existing) {
+        conversationId = existing;
+      }
+    }
+    if (!conversationId) {
+      const conv = await createConversation(baseName, "volute", {
+        userId: user.id !== 0 ? user.id : void 0,
+        title,
+        participantIds
+      });
+      conversationId = conv.id;
+    }
+  }
+  const channel = `volute:${conversationId}`;
+  const contentBlocks = [];
+  if (body.message) {
+    contentBlocks.push({ type: "text", text: body.message });
+  }
+  if (body.images) {
+    for (const img of body.images) {
+      contentBlocks.push({ type: "image", media_type: img.media_type, data: img.data });
+    }
+  }
+  await addMessage(conversationId, "user", senderName, contentBlocks);
+  const participants = await getParticipants(conversationId);
+  const agentParticipants = participants.filter((p) => p.userType === "agent");
+  const participantNames = participants.map((p) => p.username);
+  const { getAgentManager: getAgentManager2 } = await import("./agent-manager-JDVXU3ON.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 typingMap = getTypingMap();
+  const currentlyTyping = typingMap.get(channel);
+  const payload = JSON.stringify({
+    content: contentBlocks,
+    channel,
+    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)}`
+        );
+      }
+    } 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 })
+    });
+    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 = app11;
+
+// 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 app12 = new Hono12().get("/:name/conversations", async (c) => {
+  const name = c.req.param("name");
+  const user = c.get("user");
+  let lookupId = user.id;
+  if (user.id === 0) {
+    const agentUser = await getOrCreateAgentUser(name);
+    lookupId = agentUser.id;
+  }
+  const all = await listConversationsForUser(lookupId);
+  const convs = all.filter((c2) => c2.agent_name === name);
+  return c.json(convs);
+}).post("/:name/conversations", zValidator5("json", createConvSchema), async (c) => {
+  const name = c.req.param("name");
+  const user = c.get("user");
+  const body = c.req.valid("json");
+  if (!body.participantIds?.length && !body.participantNames?.length) {
+    return c.json({ error: "participantIds or participantNames required" }, 400);
+  }
+  const agentUser = await getOrCreateAgentUser(name);
+  const participantSet = /* @__PURE__ */ new Set();
+  if (user.id !== 0) participantSet.add(user.id);
+  participantSet.add(agentUser.id);
+  for (const id of body.participantIds ?? []) participantSet.add(id);
+  if (body.participantNames) {
+    for (const pname of body.participantNames) {
+      const existing = await getUserByUsername(pname);
+      if (existing) {
+        participantSet.add(existing.id);
+        continue;
+      }
+      if (findAgent(pname)) {
+        const au = await getOrCreateAgentUser(pname);
+        participantSet.add(au.id);
+        continue;
+      }
+      return c.json({ error: `User not found: ${pname}` }, 400);
+    }
+  }
+  for (const id of participantSet) {
+    if (id === user.id || id === agentUser.id) continue;
+    const u = await getUser(id);
+    if (!u) return c.json({ error: `User ${id} not found` }, 400);
+  }
+  const 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
+  });
+  return c.json(conv, 201);
+}).get("/:name/conversations/:id/messages", async (c) => {
+  const id = c.req.param("id");
+  const user = c.get("user");
+  if (user.id !== 0 && !await isParticipantOrOwner(id, user.id)) {
+    return c.json({ error: "Conversation not found" }, 404);
+  }
+  const msgs = await getMessages(id);
+  return c.json(msgs);
+}).get("/:name/conversations/:id/participants", async (c) => {
+  const id = c.req.param("id");
+  const user = c.get("user");
+  if (user.id !== 0 && !await isParticipantOrOwner(id, user.id)) {
+    return c.json({ error: "Conversation not found" }, 404);
+  }
+  const participants = await getParticipants(id);
+  return c.json(participants);
+}).delete("/:name/conversations/:id", async (c) => {
+  const id = c.req.param("id");
+  const user = c.get("user");
+  const deleted = await deleteConversationForUser(id, user.id);
+  if (!deleted) return c.json({ error: "Conversation not found" }, 404);
+  return c.json({ ok: true });
+});
+var conversations_default = app12;
+
+// 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 app13 = new Hono13().use("*", authMiddleware).get("/", async (c) => {
+  const user = c.get("user");
+  const convs = await listConversationsWithParticipants(user.id);
+  return c.json(convs);
+}).get("/:id/messages", async (c) => {
+  const id = c.req.param("id");
+  const user = c.get("user");
+  if (user.id !== 0 && !await isParticipantOrOwner(id, user.id)) {
+    return c.json({ error: "Conversation not found" }, 404);
+  }
+  const msgs = await getMessages(id);
+  return c.json(msgs);
+}).post("/", zValidator6("json", createSchema), async (c) => {
+  const user = c.get("user");
+  const body = c.req.valid("json");
+  const participantIds = /* @__PURE__ */ new Set();
+  if (user.id !== 0) participantIds.add(user.id);
+  let firstAgentName;
+  for (const name of body.participantNames) {
+    const existing = await getUserByUsername(name);
+    if (existing) {
+      participantIds.add(existing.id);
+      if (!firstAgentName && existing.user_type === "agent") firstAgentName = name;
+      continue;
+    }
+    if (findAgent(name)) {
+      const au = await getOrCreateAgentUser(name);
+      participantIds.add(au.id);
+      if (!firstAgentName) firstAgentName = name;
+      continue;
+    }
+    return c.json({ error: `User not found: ${name}` }, 400);
+  }
+  if (!firstAgentName) {
+    return c.json({ error: "At least one agent participant is required" }, 400);
+  }
+  const conv = await createConversation(firstAgentName, "volute", {
+    userId: user.id !== 0 ? user.id : void 0,
+    title: body.title,
+    participantIds: [...participantIds]
+  });
+  return c.json(conv, 201);
+}).delete("/:id", async (c) => {
+  const id = c.req.param("id");
+  const user = c.get("user");
+  const deleted = await deleteConversationForUser(id, user.id);
+  if (!deleted) return c.json({ error: "Conversation not found" }, 404);
+  return c.json({ ok: true });
+});
+var user_conversations_default = app13;
+
 // src/web/app.ts
-var app11 = new Hono11();
-app11.onError((err, c) => {
+var app14 = new Hono14();
+app14.onError((err, c) => {
   if (err instanceof HTTPException) {
     return err.getResponse();
   }
@@ -1645,10 +2496,10 @@ app11.onError((err, c) => {
   });
   return c.json({ error: "Internal server error" }, 500);
 });
-app11.notFound((c) => {
+app14.notFound((c) => {
   return c.json({ error: "Not found" }, 404);
 });
-app11.use("*", async (c, next) => {
+app14.use("*", async (c, next) => {
   const start = Date.now();
   await next();
   const duration = Date.now() - start;
@@ -1659,15 +2510,28 @@ app11.use("*", async (c, next) => {
     duration
   });
 });
-app11.get("/api/health", (c) => {
-  return c.json({ ok: true, version: "0.1.0" });
+app14.get("/api/health", (c) => {
+  let version = "unknown";
+  let cached = null;
+  try {
+    version = getCurrentVersion();
+    cached = checkForUpdateCached();
+  } catch (err) {
+    logger_default.error("Health check error", { error: err.message });
+  }
+  return c.json({
+    ok: true,
+    version,
+    ...cached?.updateAvailable ? { updateAvailable: true, latest: cached.latest } : {}
+  });
 });
-app11.use("/api/*", bodyLimit({ maxSize: 10 * 1024 * 1024 }));
-app11.use("/api/*", csrf());
-app11.use("/api/agents/*", authMiddleware);
-app11.use("/api/system/*", authMiddleware);
-var routes = app11.route("/api/auth", auth_default).route("/api/system", system_default).route("/api/agents", agents_default).route("/api/agents", chat_default).route("/api/agents", connectors_default).route("/api/agents", schedules_default).route("/api/agents", logs_default).route("/api/agents", variants_default).route("/api/agents", files_default).route("/api/agents", conversations_default);
-var app_default = app11;
+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 = {
@@ -1686,7 +2550,7 @@ async function startServer({
   let assetsDir = "";
   let searchDir = dirname3(new URL(import.meta.url).pathname);
   for (let i = 0; i < 5; i++) {
-    const candidate = resolve8(searchDir, "dist", "web-assets");
+    const candidate = resolve9(searchDir, "dist", "web-assets");
     if (existsSync7(candidate)) {
       assetsDir = candidate;
       break;
@@ -1696,7 +2560,8 @@ async function startServer({
   if (assetsDir) {
     app_default.get("*", async (c) => {
       const urlPath = new URL(c.req.url).pathname;
-      const filePath = resolve8(assetsDir, urlPath.slice(1));
+      if (urlPath.startsWith("/api/")) return c.notFound();
+      const filePath = resolve9(assetsDir, urlPath.slice(1));
       if (!filePath.startsWith(assetsDir)) return c.text("Forbidden", 403);
       const s = await stat(filePath).catch(() => null);
       if (s?.isFile()) {
@@ -1705,7 +2570,7 @@ async function startServer({
         const body = await readFile2(filePath);
         return c.body(body, 200, { "Content-Type": mime });
       }
-      const indexPath = resolve8(assetsDir, "index.html");
+      const indexPath = resolve9(assetsDir, "index.html");
       const indexStat = await stat(indexPath).catch(() => null);
       if (indexStat?.isFile()) {
         const body = await readFile2(indexPath, "utf-8");
@@ -1715,10 +2580,10 @@ async function startServer({
     });
   }
   const server = serve({ fetch: app_default.fetch, port, hostname });
-  await new Promise((resolve10, reject) => {
+  await new Promise((resolve11, reject) => {
     server.on("listening", () => {
       logger_default.info("Volute UI running", { hostname, port });
-      resolve10();
+      resolve11();
     });
     server.on("error", (err) => {
       reject(err);
@@ -1728,15 +2593,28 @@ async function startServer({
 }
 
 // src/daemon.ts
+if (!process.env.VOLUTE_HOME) {
+  process.env.VOLUTE_HOME = resolve10(homedir(), ".volute");
+}
 async function startDaemon(opts) {
   const { port, hostname } = opts;
   const myPid = String(process.pid);
   const home = voluteHome();
-  const DAEMON_PID_PATH = resolve9(home, "daemon.pid");
-  const DAEMON_JSON_PATH = resolve9(home, "daemon.json");
+  if (!opts.foreground) {
+    const log2 = new RotatingLog(resolve10(home, "daemon.log"));
+    const write2 = (...args) => log2.write(`${format(...args)}
+`);
+    console.log = write2;
+    console.error = write2;
+    console.warn = write2;
+    console.info = write2;
+  }
+  const DAEMON_PID_PATH = resolve10(home, "daemon.pid");
+  const DAEMON_JSON_PATH = resolve10(home, "daemon.json");
   mkdirSync2(home, { recursive: true });
   const token = process.env.VOLUTE_DAEMON_TOKEN || randomBytes(32).toString("hex");
   process.env.VOLUTE_DAEMON_TOKEN = token;
+  process.env.VOLUTE_DAEMON_HOSTNAME = hostname;
   let server;
   try {
     server = await startServer({ port, hostname });
@@ -1758,6 +2636,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;
@@ -1766,6 +2646,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);
@@ -1786,13 +2674,13 @@ async function startDaemon(opts) {
   console.error(`[daemon] running on ${hostname}:${port}, pid ${myPid}`);
   function cleanup() {
     try {
-      if (readFileSync4(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
+      if (readFileSync5(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
         unlinkSync2(DAEMON_PID_PATH);
       }
     } catch {
     }
     try {
-      const data = JSON.parse(readFileSync4(DAEMON_JSON_PATH, "utf-8"));
+      const data = JSON.parse(readFileSync5(DAEMON_JSON_PATH, "utf-8"));
       if (data.token === token) {
         unlinkSync2(DAEMON_JSON_PATH);
       }
@@ -1806,6 +2694,7 @@ async function startDaemon(opts) {
     console.error("[daemon] shutting down...");
     scheduler.stop();
     scheduler.saveState();
+    tokenBudget.stop();
     await connectors.stopAll();
     await manager.stopAll();
     manager.clearCrashAttempts();