volute 0.5.0 → 0.6.0

package/dist/daemon.js

@@ -6,34 +6,36 @@ import {
   initAgentManager,
   loadJsonMap,
   saveJsonMap
-} from "./chunk-MW2KFO3B.js";
+} from "./chunk-G6ZNGLUX.js";
 import {
   checkForUpdate,
   checkForUpdateCached,
   getCurrentVersion
-} from "./chunk-5X7HGB6L.js";
-import {
-  CHANNELS
-} from "./chunk-SMISE4SV.js";
+} from "./chunk-AOKAQGO4.js";
 import {
   collectPart
 } from "./chunk-B3R6L2GW.js";
+import {
+  CHANNELS
+} from "./chunk-ZZOOTYXK.js";
 import {
   readVoluteConfig,
   writeVoluteConfig
 } from "./chunk-NETNFBA5.js";
 import {
   loadMergedEnv
-} from "./chunk-HE67X4T6.js";
+} from "./chunk-H7AMDUIA.js";
+import "./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,7 +46,7 @@ import {
   setAgentRunning,
   setVariantRunning,
   voluteHome
-} from "./chunk-UX25Z2ND.js";
+} from "./chunk-UWHWAPGO.js";
 import {
   __export
 } from "./chunk-K3NQKI34.js";
@@ -232,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
@@ -478,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: {
@@ -527,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";
@@ -878,7 +1054,7 @@ 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";
@@ -929,6 +1105,73 @@ 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 {
@@ -945,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.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 };
@@ -1015,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) {
@@ -1036,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);
@@ -1044,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) {
@@ -1066,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 });
@@ -1081,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);
@@ -1134,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);
@@ -1153,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();
@@ -1271,100 +1631,437 @@ 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) {
-  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)));
-    }
+  const config = readVoluteConfig(dir) ?? {};
+  const connectors = config.connectors ?? [];
+  if (!connectors.includes(type)) {
+    config.connectors = [...connectors, type];
+    writeVoluteConfig(dir, config);
   }
-  return {
-    id: result.id,
-    conversation_id: conversationId,
-    role,
+  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 existsSync5 } from "fs";
+import { readdir, readFile, writeFile } from "fs/promises";
+import { resolve as resolve6 } from "path";
+import { zValidator as zValidator2 } from "@hono/zod-validator";
+import { Hono as Hono4 } from "hono";
+import { z as z2 } from "zod";
+var ALLOWED_FILES = /* @__PURE__ */ new Set(["SOUL.md", "MEMORY.md", "CLAUDE.md", "VOLUTE.md"]);
+var saveFileSchema = z2.object({ content: z2.string() });
+var app4 = new Hono4().get("/:name/files", async (c) => {
+  const name = c.req.param("name");
+  const entry = findAgent(name);
+  if (!entry) return c.json({ error: "Agent not found" }, 404);
+  const dir = agentDir(name);
+  const homeDir = resolve6(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 = resolve6(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", zValidator2("json", saveFileSchema), async (c) => {
+  const name = c.req.param("name");
+  const filename = c.req.param("filename");
+  if (!ALLOWED_FILES.has(filename)) {
+    return c.json({ error: "File not allowed" }, 403);
+  }
+  const entry = findAgent(name);
+  if (!entry) return c.json({ error: "Agent not found" }, 404);
+  const dir = agentDir(name);
+  const filePath = resolve6(dir, "home", filename);
+  const { content } = c.req.valid("json");
+  await writeFile(filePath, content);
+  return c.json({ ok: true });
+});
+var files_default = app4;
+
+// 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 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 = resolve7(dir, ".volute", "logs", "agent.log");
+  if (!existsSync6(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((resolve11) => {
+      tail.on("exit", resolve11);
+      stream2.onAbort(resolve11);
+    });
+  });
+});
+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((resolve11) => {
+      stream2.onAbort(() => {
+        unsubscribe();
+        resolve11();
+      });
+    });
+  });
+});
+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 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
@@ -1412,26 +2109,39 @@ async function listConversationsWithParticipants(userId) {
   }
   return convs.map((c) => ({ ...c, participants: byConv.get(c.id) ?? [] }));
 }
+async function findDMConversation(agentName, participantIds) {
+  const db2 = await getDb();
+  const agentConvs = await db2.select({ id: conversations.id }).from(conversations).where(eq4(conversations.agent_name, agentName)).all();
+  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/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(resolve8(voluteHome(), "daemon.json"), "utf-8"));
+  return `http://${daemonLoopback()}:${data.port}`;
 }
 function daemonFetchInternal(path, body) {
   const daemonUrl = getDaemonUrl();
@@ -1476,15 +2186,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,12 +2216,20 @@ 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 conv = await createConversation(baseName, "volute", {
+        userId: user.id !== 0 ? user.id : void 0,
+        title,
+        participantIds
+      });
+      conversationId = conv.id;
+    }
   }
   const channel = `volute:${conversationId}`;
   const contentBlocks = [];
@@ -1531,22 +2245,23 @@ 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-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);
-  if (runningAgents.length === 0) {
-    return c.json({ error: "No running agents in this conversation" }, 409);
-  }
   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
+    isDM,
+    ...currentlyTyping.length > 0 ? { typing: currentlyTyping } : {}
   });
   const responses = [];
   for (const agentName of runningAgents) {
@@ -1569,12 +2284,17 @@ 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 })
     });
@@ -1585,114 +2305,43 @@ var app3 = new Hono3().post("/:name/chat", zValidator2("json", chatSchema), asyn
         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 });
+    } 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 +2352,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 +2384,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 +2410,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 +2422,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;
+var conversations_default = app12;
 
-// 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;
-
-// 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 +2444,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 +2481,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 +2496,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 +2510,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 +2525,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 = {
@@ -2189,6 +2614,7 @@ async function startDaemon(opts) {
   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 +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;
@@ -2218,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);
@@ -2258,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();