volute 0.7.0 → 0.8.1

package/dist/daemon.js

@@ -6,18 +6,15 @@ import {
   initAgentManager,
   loadJsonMap,
   saveJsonMap
-} from "./chunk-62X577Y7.js";
+} from "./chunk-W6TMWYU3.js";
 import {
   checkForUpdate,
   checkForUpdateCached,
   getCurrentVersion
-} from "./chunk-NKXULRSW.js";
-import {
-  collectPart
-} from "./chunk-B3R6L2GW.js";
+} from "./chunk-RT6Y7AR3.js";
 import {
   CHANNELS
-} from "./chunk-ZZOOTYXK.js";
+} from "./chunk-LIPPXNIE.js";
 import {
   agentMessages,
   approveUser,
@@ -36,24 +33,24 @@ import {
   sessions,
   users,
   verifyUser
-} from "./chunk-7ACDT3P2.js";
+} from "./chunk-ECPQXRLB.js";
 import {
   readVoluteConfig,
   writeVoluteConfig
 } from "./chunk-NETNFBA5.js";
 import {
   loadMergedEnv
-} from "./chunk-H7AMDUIA.js";
+} from "./chunk-QF22MYDJ.js";
 import {
   slugify,
   writeChannelEntry
-} from "./chunk-BX7KI4S3.js";
+} from "./chunk-N6MLQ26B.js";
 import {
   applyIsolation
-} from "./chunk-W76KWE23.js";
+} from "./chunk-IQXBMFZG.js";
 import {
   resolveVoluteBin
-} from "./chunk-5SKQ6J7T.js";
+} from "./chunk-5C5JWR2L.js";
 import {
   agentDir,
   checkHealth,
@@ -67,15 +64,17 @@ import {
   removeAllVariants,
   setAgentRunning,
   setVariantRunning,
+  stateDir,
+  validateBranchName,
   voluteHome
-} from "./chunk-UWHWAPGO.js";
+} from "./chunk-DP2DX4WV.js";
 import "./chunk-K3NQKI34.js";
 
 // src/daemon.ts
 import { randomBytes } from "crypto";
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
 import { homedir } from "os";
-import { resolve as resolve9 } from "path";
+import { resolve as resolve10 } from "path";
 import { format } from "util";
 
 // src/lib/connector-manager.ts
@@ -186,13 +185,13 @@ var ConnectorManager = class {
       }
     }
   }
-  checkConnectorEnv(type, agentDir2) {
+  checkConnectorEnv(type, agentName, agentDir2) {
     const agentConnectorDir = resolve2(agentDir2, "connectors", type);
     const userConnectorDir = resolve2(voluteHome(), "connectors", type);
     const connectorDir = existsSync2(agentConnectorDir) ? agentConnectorDir : existsSync2(userConnectorDir) ? userConnectorDir : void 0;
     const def = getConnectorDef(type, connectorDir);
     if (!def) return null;
-    const env = loadMergedEnv(agentDir2);
+    const env = loadMergedEnv(agentName);
     const missing = checkMissingEnvVars(def, env);
     if (missing.length === 0) return null;
     return {
@@ -220,7 +219,7 @@ var ConnectorManager = class {
       });
       this.connectors.get(agentName)?.delete(type);
     }
-    this.killOrphanConnector(agentDir2, type);
+    this.killOrphanConnector(agentName, type);
     const agentConnector = resolve2(agentDir2, "connectors", type, "index.ts");
     const userConnector = resolve2(voluteHome(), "connectors", type, "index.ts");
     const builtinConnector = this.resolveBuiltinConnector(type);
@@ -238,10 +237,10 @@ var ConnectorManager = class {
     } else {
       throw new Error(`No connector code found for type: ${type}`);
     }
-    const logsDir = resolve2(agentDir2, ".volute", "logs");
+    const logsDir = resolve2(stateDir(agentName), "logs");
     mkdirSync(logsDir, { recursive: true });
     const logStream = new RotatingLog(resolve2(logsDir, `${type}.log`));
-    const agentEnv = loadMergedEnv(agentDir2);
+    const agentEnv = loadMergedEnv(agentName);
     const prefix = `${type.toUpperCase()}_`;
     const connectorEnv = Object.fromEntries(
       Object.entries(agentEnv).filter(([k]) => k.startsWith(prefix))
@@ -269,7 +268,7 @@ var ConnectorManager = class {
       lastStderr = chunk.toString().trim();
     });
     if (child.pid) {
-      this.saveConnectorPid(agentDir2, type, child.pid);
+      this.saveConnectorPid(agentName, type, child.pid);
     }
     if (!this.connectors.has(agentName)) {
       this.connectors.set(agentName, /* @__PURE__ */ new Map());
@@ -315,26 +314,27 @@ 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);
     this.restartAttempts.delete(stopKey);
     try {
-      this.removeConnectorPid(agentDir(agentName), type);
-    } catch {
+      this.removeConnectorPid(agentName, type);
+    } catch (err) {
+      console.error(`[daemon] failed to remove PID file for ${type}/${agentName}:`, err);
     }
     console.error(`[daemon] stopped connector ${type} for ${agentName}`);
   }
@@ -358,22 +358,22 @@ var ConnectorManager = class {
       running: !tracked.child.killed
     }));
   }
-  connectorPidPath(agentDir2, type) {
-    return resolve2(agentDir2, ".volute", "connectors", `${type}.pid`);
+  connectorPidPath(agentName, type) {
+    return resolve2(stateDir(agentName), "connectors", `${type}.pid`);
   }
-  saveConnectorPid(agentDir2, type, pid) {
-    const pidPath = this.connectorPidPath(agentDir2, type);
+  saveConnectorPid(agentName, type, pid) {
+    const pidPath = this.connectorPidPath(agentName, type);
     mkdirSync(dirname(pidPath), { recursive: true });
     writeFileSync(pidPath, String(pid));
   }
-  removeConnectorPid(agentDir2, type) {
+  removeConnectorPid(agentName, type) {
     try {
-      unlinkSync(this.connectorPidPath(agentDir2, type));
+      unlinkSync(this.connectorPidPath(agentName, type));
     } catch {
     }
   }
-  killOrphanConnector(agentDir2, type) {
-    const pidPath = this.connectorPidPath(agentDir2, type);
+  killOrphanConnector(agentName, type) {
+    const pidPath = this.connectorPidPath(agentName, type);
     if (!existsSync2(pidPath)) return;
     try {
       const pid = parseInt(readFileSync2(pidPath, "utf-8").trim(), 10);
@@ -406,8 +406,37 @@ function getConnectorManager() {
   return instance;
 }
 
-// src/lib/scheduler.ts
+// src/lib/migrate-state.ts
+import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync } from "fs";
 import { resolve as resolve3 } from "path";
+function migrateAgentState(name) {
+  const src = resolve3(agentDir(name), ".volute");
+  if (!existsSync3(src)) return;
+  const dest = stateDir(name);
+  mkdirSync2(dest, { recursive: true });
+  for (const file of ["env.json", "channels.json"]) {
+    const srcPath = resolve3(src, file);
+    const destPath = resolve3(dest, file);
+    if (existsSync3(srcPath) && !existsSync3(destPath)) {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+  const srcLogs = resolve3(src, "logs");
+  const destLogs = resolve3(dest, "logs");
+  if (existsSync3(srcLogs) && !existsSync3(destLogs)) {
+    mkdirSync2(destLogs, { recursive: true });
+    for (const file of readdirSync(srcLogs)) {
+      try {
+        copyFileSync(resolve3(srcLogs, file), resolve3(destLogs, file));
+      } catch (err) {
+        console.error(`[migrate] failed to copy log ${file} for ${name}:`, err);
+      }
+    }
+  }
+}
+
+// src/lib/scheduler.ts
+import { resolve as resolve4 } from "path";
 import { CronExpressionParser } from "cron-parser";
 var Scheduler = class {
   schedules = /* @__PURE__ */ new Map();
@@ -417,7 +446,7 @@ var Scheduler = class {
   daemonPort = null;
   daemonToken = null;
   get statePath() {
-    return resolve3(voluteHome(), "scheduler-state.json");
+    return resolve4(voluteHome(), "scheduler-state.json");
   }
   start(daemonPort, daemonToken) {
     this.daemonPort = daemonPort ?? null;
@@ -524,18 +553,8 @@ var Scheduler = class {
       } else {
         console.error(`[scheduler] fired "${schedule.id}" for ${agentName}`);
       }
-      try {
-        const reader = res.body?.getReader();
-        if (reader) {
-          try {
-            while (!(await reader.read()).done) {
-            }
-          } finally {
-            reader.releaseLock();
-          }
-        }
-      } catch {
-      }
+      await res.text().catch(() => {
+      });
     } catch (err) {
       console.error(`[scheduler] failed to fire "${schedule.id}" for ${agentName}:`, err);
     } finally {
@@ -696,18 +715,8 @@ ${summary}`
           `[token-budget] replayed ${messages2.length} queued message(s) for ${agentName}`
         );
       }
-      try {
-        const reader = res.body?.getReader();
-        if (reader) {
-          try {
-            while (!(await reader.read()).done) {
-            }
-          } finally {
-            reader.releaseLock();
-          }
-        }
-      } catch {
-      }
+      await res.text().catch(() => {
+      });
     } catch (err) {
       console.error(`[token-budget] failed to replay for ${agentName}:`, err);
       const state = this.budgets.get(agentName);
@@ -788,9 +797,9 @@ var authMiddleware = createMiddleware(async (c, next) => {
 });
 
 // src/web/server.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { readFile as readFile2, stat } from "fs/promises";
-import { dirname as dirname2, extname, resolve as resolve8 } from "path";
+import { dirname as dirname2, extname, resolve as resolve9 } from "path";
 import { serve } from "@hono/node-server";
 
 // src/lib/log-buffer.ts
@@ -844,50 +853,12 @@ import { csrf } from "hono/csrf";
 import { HTTPException } from "hono/http-exception";
 
 // src/web/routes/agents.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, rmSync } from "fs";
-import { resolve as resolve4 } from "path";
+import { execFile } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync3, rmSync } from "fs";
+import { resolve as resolve5 } from "path";
+import { promisify } from "util";
 import { and, desc, eq as eq2 } from "drizzle-orm";
 import { Hono } from "hono";
-import { stream } from "hono/streaming";
-
-// src/lib/ndjson.ts
-var MAX_BUFFER_SIZE = 1e6;
-async function* readNdjson(body) {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      if (buffer.length > MAX_BUFFER_SIZE) {
-        logger_default.warn("ndjson: buffer exceeded 1MB, resetting");
-        buffer = "";
-        continue;
-      }
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        try {
-          yield JSON.parse(line);
-        } catch {
-          logger_default.warn("ndjson: skipping invalid line", { line: line.slice(0, 100) });
-        }
-      }
-    }
-    if (buffer.trim()) {
-      try {
-        yield JSON.parse(buffer);
-      } catch {
-        logger_default.warn("ndjson: skipping invalid line", { line: buffer.slice(0, 100) });
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}
 
 // src/lib/typing.ts
 var DEFAULT_TTL_MS = 1e4;
@@ -957,11 +928,38 @@ function getTypingMap() {
 }
 
 // src/web/routes/agents.ts
+var execFileAsync = promisify(execFile);
+async function startAgentFull(name, baseName, variantName) {
+  await getAgentManager().startAgent(name);
+  if (variantName) return;
+  const dir = agentDir(baseName);
+  const entry = findAgent(baseName);
+  await getConnectorManager().startConnectors(baseName, dir, entry.port, getDaemonPort());
+  getScheduler().loadSchedules(baseName);
+  const config = readVoluteConfig(dir);
+  if (config?.tokenBudget) {
+    getTokenBudget().setBudget(
+      baseName,
+      config.tokenBudget,
+      config.tokenBudgetPeriodMinutes ?? DEFAULT_BUDGET_PERIOD_MINUTES
+    );
+  }
+}
+function extractTextContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter((p) => p.type === "text" && p.text).map((p) => p.text).join("\n");
+  }
+  return JSON.stringify(content);
+}
 function getDaemonPort() {
   try {
-    const data = JSON.parse(readFileSync3(resolve4(voluteHome(), "daemon.json"), "utf-8"));
+    const data = JSON.parse(readFileSync3(resolve5(voluteHome(), "daemon.json"), "utf-8"));
     return data.port;
-  } catch {
+  } catch (err) {
+    if (err?.code !== "ENOENT") {
+      console.error("[daemon] failed to read daemon.json:", err);
+    }
     return void 0;
   }
 }
@@ -1008,7 +1006,7 @@ var app = new Hono().get("/", async (c) => {
   const name = c.req.param("name");
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
-  if (!existsSync3(agentDir(name))) return c.json({ error: "Agent directory missing" }, 404);
+  if (!existsSync4(agentDir(name))) return c.json({ error: "Agent directory missing" }, 404);
   const { status, channels } = await getAgentStatus(name, entry.port);
   const variants = readVariants(name);
   const manager = getAgentManager();
@@ -1034,27 +1032,13 @@ var app = new Hono().get("/", async (c) => {
     if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
   } else {
     const dir = agentDir(baseName);
-    if (!existsSync3(dir)) return c.json({ error: "Agent directory missing" }, 404);
+    if (!existsSync4(dir)) return c.json({ error: "Agent directory missing" }, 404);
   }
-  const manager = getAgentManager();
-  if (manager.isRunning(name)) {
+  if (getAgentManager().isRunning(name)) {
     return c.json({ error: "Agent already running" }, 409);
   }
   try {
-    await manager.startAgent(name);
-    if (!variantName) {
-      const dir = agentDir(baseName);
-      await getConnectorManager().startConnectors(baseName, dir, entry.port, getDaemonPort());
-      getScheduler().loadSchedules(baseName);
-      const config = readVoluteConfig(dir);
-      if (config?.tokenBudget) {
-        getTokenBudget().setBudget(
-          baseName,
-          config.tokenBudget,
-          config.tokenBudgetPeriodMinutes ?? DEFAULT_BUDGET_PERIOD_MINUTES
-        );
-      }
-    }
+    await startAgentFull(name, baseName, variantName);
     return c.json({ ok: true });
   } catch (err) {
     return c.json({ error: err instanceof Error ? err.message : "Failed to start agent" }, 500);
@@ -1069,32 +1053,54 @@ var app = new Hono().get("/", async (c) => {
     if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
   } else {
     const dir = agentDir(baseName);
-    if (!existsSync3(dir)) return c.json({ error: "Agent directory missing" }, 404);
+    if (!existsSync4(dir)) return c.json({ error: "Agent directory missing" }, 404);
+  }
+  let context;
+  const contentType = c.req.header("content-type");
+  if (contentType?.includes("application/json")) {
+    try {
+      const body = await c.req.json();
+      if (body?.context) context = body.context;
+    } catch (err) {
+      console.error(`[daemon] failed to parse restart context for ${name}:`, err);
+    }
   }
   const manager = getAgentManager();
-  const connectorManager = getConnectorManager();
   try {
     if (manager.isRunning(name)) {
       if (!variantName) {
-        await connectorManager.stopConnectors(baseName);
+        await getConnectorManager().stopConnectors(baseName);
         getTokenBudget().removeBudget(baseName);
       }
       await manager.stopAgent(name);
     }
-    await manager.startAgent(name);
-    if (!variantName) {
-      const dir = agentDir(baseName);
-      await connectorManager.startConnectors(baseName, dir, entry.port, getDaemonPort());
-      getScheduler().loadSchedules(baseName);
-      const config = readVoluteConfig(dir);
-      if (config?.tokenBudget) {
-        getTokenBudget().setBudget(
-          baseName,
-          config.tokenBudget,
-          config.tokenBudgetPeriodMinutes ?? DEFAULT_BUDGET_PERIOD_MINUTES
-        );
+    if (context?.type === "merge" && context.name && !variantName) {
+      const mergeVariantName = String(context.name);
+      const branchErr = validateBranchName(mergeVariantName);
+      if (branchErr) {
+        return c.json({ error: `Invalid variant name: ${branchErr}` }, 400);
       }
+      console.error(`[daemon] merging variant for ${baseName}: ${mergeVariantName}`);
+      const mergeArgs = [
+        "variant",
+        "merge",
+        mergeVariantName,
+        "--agent",
+        baseName,
+        "--skip-verify"
+      ];
+      if (context.summary) mergeArgs.push("--summary", String(context.summary));
+      if (context.justification) mergeArgs.push("--justification", String(context.justification));
+      if (context.memory) mergeArgs.push("--memory", String(context.memory));
+      await execFileAsync("volute", mergeArgs, {
+        cwd: agentDir(baseName),
+        env: { ...process.env, VOLUTE_SUPERVISOR: "1" }
+      });
     }
+    if (context) {
+      manager.setPendingContext(name, context);
+    }
+    await startAgentFull(name, baseName, variantName);
     return c.json({ ok: true });
   } catch (err) {
     return c.json({ error: err instanceof Error ? err.message : "Failed to restart agent" }, 500);
@@ -1138,7 +1144,11 @@ var app = new Hono().get("/", async (c) => {
   removeAllVariants(name);
   removeAgent(name);
   await deleteAgentUser(name);
-  if (force && existsSync3(dir)) {
+  const state = stateDir(name);
+  if (existsSync4(state)) {
+    rmSync(state, { recursive: true, force: true });
+  }
+  if (force && existsSync4(dir)) {
     rmSync(dir, { recursive: true, force: true });
   }
   return c.json({ ok: true });
@@ -1168,18 +1178,10 @@ var app = new Hono().get("/", async (c) => {
   if (parsed) {
     try {
       const sender2 = parsed.sender ?? null;
-      let content;
-      if (typeof parsed.content === "string") {
-        content = parsed.content;
-      } else if (Array.isArray(parsed.content)) {
-        content = parsed.content.filter((p) => p.type === "text" && p.text).map((p) => p.text).join("\n");
-      } else {
-        content = JSON.stringify(parsed.content);
-      }
+      const content = extractTextContent(parsed.content);
       await db.insert(agentMessages).values({
         agent: baseName,
         channel,
-        role: "user",
         sender: sender2,
         content
       });
@@ -1190,31 +1192,13 @@ var app = new Hono().get("/", async (c) => {
   const budget = getTokenBudget();
   const budgetStatus = budget.checkBudget(baseName);
   if (budgetStatus === "exceeded") {
-    let textContent = "";
-    if (parsed) {
-      if (typeof parsed.content === "string") {
-        textContent = parsed.content;
-      } else if (Array.isArray(parsed.content)) {
-        textContent = parsed.content.filter((p) => p.type === "text" && p.text).map((p) => p.text).join("\n");
-      }
-    }
+    const textContent = parsed ? extractTextContent(parsed.content) : "";
     budget.enqueue(baseName, {
       channel,
       sender: parsed?.sender ?? null,
       textContent
     });
-    c.header("Content-Type", "application/x-ndjson");
-    const encoder2 = new TextEncoder();
-    return stream(c, async (s) => {
-      await s.write(
-        encoder2.encode(
-          `${JSON.stringify({ type: "text", content: "[Token budget exceeded \u2014 message queued for next period]" })}
-`
-        )
-      );
-      await s.write(encoder2.encode(`${JSON.stringify({ type: "done" })}
-`));
-    });
+    return c.json({ error: "Token budget exceeded \u2014 message queued for next period" }, 429);
   }
   const typingMap = getTypingMap();
   const sender = parsed?.sender ?? "";
@@ -1238,63 +1222,38 @@ var app = new Hono().get("/", async (c) => {
     budget.acknowledgeWarning(baseName);
     forwardBody = JSON.stringify(parsed);
   }
-  let res;
+  typingMap.set(channel, baseName, { persistent: true });
+  const conversationId = parsed?.conversationId ?? null;
+  if (conversationId) typingMap.set(`volute:${conversationId}`, baseName, { persistent: true });
   try {
-    res = await fetch(`http://127.0.0.1:${port}/message`, {
+    const res = await fetch(`http://127.0.0.1:${port}/message`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: forwardBody
     });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      console.error(`[daemon] agent ${name} responded with ${res.status}: ${text}`);
+      return c.json({ error: `Agent responded with ${res.status}` }, res.status);
+    }
+    let result;
+    try {
+      result = await res.json();
+    } catch (parseErr) {
+      console.error(`[daemon] agent ${name} returned non-JSON response:`, parseErr);
+      return c.json({ error: "Agent returned invalid response" }, 502);
+    }
+    if (result.usage) {
+      budget.recordUsage(baseName, result.usage.input_tokens, result.usage.output_tokens);
+    }
+    return c.json({ ok: true });
   } catch (err) {
     console.error(`[daemon] agent ${name} unreachable on port ${port}:`, err);
     return c.json({ error: "Agent is not reachable" }, 502);
+  } finally {
+    typingMap.delete(channel, baseName);
+    if (conversationId) typingMap.delete(`volute:${conversationId}`, baseName);
   }
-  if (!res.ok) {
-    return c.json({ error: `Agent responded with ${res.status}` }, res.status);
-  }
-  if (!res.body) {
-    return c.json({ error: "No response body from agent" }, 502);
-  }
-  c.header("Content-Type", "application/x-ndjson");
-  const encoder = new TextEncoder();
-  typingMap.set(channel, baseName, { persistent: true });
-  return stream(c, async (s) => {
-    try {
-      const textParts = [];
-      const toolParts = [];
-      for await (const event of readNdjson(res.body)) {
-        if (event.type === "usage") {
-          const input = typeof event.input_tokens === "number" ? event.input_tokens : 0;
-          const output = typeof event.output_tokens === "number" ? event.output_tokens : 0;
-          budget.recordUsage(baseName, input, output);
-          continue;
-        }
-        await s.write(encoder.encode(`${JSON.stringify(event)}
-`));
-        const part = collectPart(event);
-        if (part != null) {
-          if (event.type === "tool_use") toolParts.push(part);
-          else textParts.push(part);
-        }
-      }
-      const content = [textParts.join(""), ...toolParts].filter(Boolean).join("\n");
-      if (content) {
-        try {
-          await db.insert(agentMessages).values({
-            agent: baseName,
-            channel,
-            role: "assistant",
-            sender: baseName,
-            content
-          });
-        } catch (err) {
-          console.error(`[daemon] failed to persist assistant response for ${baseName}:`, err);
-        }
-      }
-    } finally {
-      typingMap.delete(channel, baseName);
-    }
-  });
 }).get("/:name/budget", async (c) => {
   const name = c.req.param("name");
   const [baseName] = name.split("@", 2);
@@ -1318,8 +1277,7 @@ var app = new Hono().get("/", async (c) => {
     await db.insert(agentMessages).values({
       agent: baseName,
       channel: body.channel,
-      role: "assistant",
-      sender: baseName,
+      sender: body.sender ?? baseName,
       content: body.content
     });
   } catch (err) {
@@ -1445,7 +1403,7 @@ var app3 = new Hono3().get("/:name/connectors", (c) => {
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
   const manager = getConnectorManager();
-  const envCheck = manager.checkConnectorEnv(type, dir);
+  const envCheck = manager.checkConnectorEnv(type, name, dir);
   if (envCheck) {
     return c.json(
       {
@@ -1490,21 +1448,18 @@ var app3 = new Hono3().get("/:name/connectors", (c) => {
 var connectors_default = app3;
 
 // src/web/routes/files.ts
-import { existsSync as existsSync4 } from "fs";
-import { readdir, readFile, writeFile } from "fs/promises";
-import { resolve as resolve5 } from "path";
-import { zValidator as zValidator2 } from "@hono/zod-validator";
+import { existsSync as existsSync5 } from "fs";
+import { readdir, readFile } from "fs/promises";
+import { resolve as resolve6 } from "path";
 import { Hono as Hono4 } from "hono";
-import { z as z2 } from "zod";
 var ALLOWED_FILES = /* @__PURE__ */ new Set(["SOUL.md", "MEMORY.md", "CLAUDE.md", "VOLUTE.md"]);
-var saveFileSchema = z2.object({ content: z2.string() });
 var app4 = new Hono4().get("/:name/files", async (c) => {
   const name = c.req.param("name");
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
-  const homeDir = resolve5(dir, "home");
-  if (!existsSync4(homeDir)) return c.json({ error: "Home directory missing" }, 404);
+  const 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);
@@ -1517,61 +1472,47 @@ var app4 = new Hono4().get("/:name/files", async (c) => {
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
-  const filePath = resolve5(dir, "home", filename);
-  if (!existsSync4(filePath)) {
+  const filePath = 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 = resolve5(dir, "home", filename);
-  const { content } = c.req.valid("json");
-  await writeFile(filePath, content);
-  return c.json({ ok: true });
 });
 var files_default = app4;
 
 // src/web/routes/logs.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync5 } from "fs";
-import { resolve as resolve6 } from "path";
+import { 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 = resolve6(dir, ".volute", "logs", "agent.log");
-  if (!existsSync5(logFile)) {
+  const logFile = resolve7(stateDir(name), "logs", "agent.log");
+  if (!existsSync6(logFile)) {
     return c.json({ error: "No log file found" }, 404);
   }
-  return streamSSE(c, async (stream2) => {
+  return streamSSE(c, async (stream) => {
     const tail = spawn2("tail", ["-n", "200", "-f", logFile]);
     const onData = (data) => {
       const lines = data.toString().split("\n");
       for (const line of lines) {
         if (line) {
-          stream2.writeSSE({ data: line }).catch(() => {
+          stream.writeSSE({ data: line }).catch(() => {
           });
         }
       }
     };
     tail.stdout.on("data", onData);
-    stream2.onAbort(() => {
+    stream.onAbort(() => {
       tail.kill();
     });
-    await new Promise((resolve10) => {
-      tail.on("exit", resolve10);
-      stream2.onAbort(resolve10);
+    await new Promise((resolve11) => {
+      tail.on("exit", resolve11);
+      stream.onAbort(resolve11);
     });
   });
 });
@@ -1665,18 +1606,18 @@ import { streamSSE as streamSSE2 } from "hono/streaming";
 var app7 = new Hono7().get("/logs", async (c) => {
   const user = c.get("user");
   if (user.role !== "admin") return c.json({ error: "Forbidden" }, 403);
-  return streamSSE2(c, async (stream2) => {
+  return streamSSE2(c, async (stream) => {
     for (const entry of logBuffer.getEntries()) {
-      await stream2.writeSSE({ data: JSON.stringify(entry) });
+      await stream.writeSSE({ data: JSON.stringify(entry) });
     }
     const unsubscribe = logBuffer.subscribe((entry) => {
-      stream2.writeSSE({ data: JSON.stringify(entry) }).catch(() => {
+      stream.writeSSE({ data: JSON.stringify(entry) }).catch(() => {
       });
     });
-    await new Promise((resolve10) => {
-      stream2.onAbort(() => {
+    await new Promise((resolve11) => {
+      stream.onAbort(() => {
         unsubscribe();
-        resolve10();
+        resolve11();
       });
     });
   });
@@ -1684,15 +1625,15 @@ var app7 = new Hono7().get("/logs", async (c) => {
 var system_default = app7;
 
 // src/web/routes/typing.ts
-import { zValidator as zValidator3 } from "@hono/zod-validator";
+import { zValidator as zValidator2 } from "@hono/zod-validator";
 import { Hono as Hono8 } from "hono";
-import { z as z3 } from "zod";
-var typingSchema = z3.object({
-  channel: z3.string().min(1),
-  sender: z3.string().min(1),
-  active: z3.boolean()
+import { z as z2 } from "zod";
+var typingSchema = z2.object({
+  channel: z2.string().min(1),
+  sender: z2.string().min(1),
+  active: z2.boolean()
 });
-var app8 = new Hono8().post("/:name/typing", zValidator3("json", typingSchema), (c) => {
+var app8 = new Hono8().post("/:name/typing", zValidator2("json", typingSchema), (c) => {
   const { channel, sender, active } = c.req.valid("json");
   const map = getTypingMap();
   if (active) {
@@ -1752,11 +1693,39 @@ var variants_default = app10;
 
 // src/web/routes/volute/chat.ts
 import { readFileSync as readFileSync4 } from "fs";
-import { resolve as resolve7 } from "path";
-import { zValidator as zValidator4 } from "@hono/zod-validator";
+import { resolve as resolve8 } from "path";
+import { zValidator as zValidator3 } from "@hono/zod-validator";
 import { Hono as Hono11 } from "hono";
 import { streamSSE as streamSSE3 } from "hono/streaming";
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
+
+// src/lib/conversation-events.ts
+var subscribers = /* @__PURE__ */ new Map();
+function subscribe(conversationId, callback) {
+  let set = subscribers.get(conversationId);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    subscribers.set(conversationId, set);
+  }
+  set.add(callback);
+  return () => {
+    set.delete(callback);
+    if (set.size === 0) subscribers.delete(conversationId);
+  };
+}
+function publish(conversationId, event) {
+  const set = subscribers.get(conversationId);
+  if (!set) return;
+  for (const cb of set) {
+    try {
+      cb(event);
+    } catch (err) {
+      console.error("[conversation-events] subscriber threw:", err);
+      set.delete(cb);
+      if (set.size === 0) subscribers.delete(conversationId);
+    }
+  }
+}
 
 // src/lib/conversations.ts
 import { randomUUID } from "crypto";
@@ -1845,7 +1814,7 @@ async function addMessage(conversationId, role, senderName, content) {
       await db.update(conversations).set({ title }).where(and2(eq3(conversations.id, conversationId), isNull(conversations.title)));
     }
   }
-  return {
+  const msg = {
     id: result.id,
     conversation_id: conversationId,
     role,
@@ -1853,6 +1822,15 @@ async function addMessage(conversationId, role, senderName, content) {
     content,
     created_at: result.created_at
   };
+  publish(conversationId, {
+    type: "message",
+    id: msg.id,
+    role: msg.role,
+    senderName: msg.sender_name,
+    content: msg.content,
+    createdAt: msg.created_at
+  });
+  return msg;
 }
 async function getMessages(conversationId) {
   const db = await getDb();
@@ -1915,20 +1893,24 @@ async function deleteConversation(id) {
 }
 
 // src/web/routes/volute/chat.ts
-var chatSchema = z4.object({
-  message: z4.string().optional(),
-  conversationId: z4.string().optional(),
-  sender: z4.string().optional(),
-  images: z4.array(
-    z4.object({
-      media_type: z4.string(),
-      data: z4.string()
+var chatSchema = z3.object({
+  message: z3.string().optional(),
+  conversationId: z3.string().optional(),
+  sender: z3.string().optional(),
+  images: z3.array(
+    z3.object({
+      media_type: z3.string(),
+      data: z3.string()
     })
   ).optional()
 });
 function getDaemonUrl() {
-  const data = JSON.parse(readFileSync4(resolve7(voluteHome(), "daemon.json"), "utf-8"));
-  return `http://${daemonLoopback()}:${data.port}`;
+  try {
+    const data = JSON.parse(readFileSync4(resolve8(voluteHome(), "daemon.json"), "utf-8"));
+    return `http://${daemonLoopback()}:${data.port}`;
+  } catch (err) {
+    throw new Error(`Failed to read daemon config: ${err instanceof Error ? err.message : err}`);
+  }
 }
 function daemonFetchInternal(path, body) {
   const daemonUrl = getDaemonUrl();
@@ -1940,40 +1922,7 @@ function daemonFetchInternal(path, body) {
   if (token) headers.Authorization = `Bearer ${token}`;
   return fetch(`${daemonUrl}${path}`, { method: "POST", headers, body });
 }
-function accumulateEvent(content, event) {
-  if (event.type === "text") {
-    const last = content[content.length - 1];
-    if (last && last.type === "text") last.text += event.content;
-    else content.push({ type: "text", text: event.content });
-  } else if (event.type === "tool_use") {
-    content.push({ type: "tool_use", name: event.name, input: event.input });
-  } else if (event.type === "tool_result") {
-    content.push({
-      type: "tool_result",
-      output: event.output,
-      ...event.is_error ? { is_error: true } : {}
-    });
-  }
-}
-async function consumeAndPersist(res, conversationId, agentName) {
-  if (!res.body) {
-    console.warn(`[chat] no response body from ${agentName}`);
-    return [];
-  }
-  const assistantContent = [];
-  for await (const event of readNdjson(res.body)) {
-    accumulateEvent(assistantContent, event);
-    if (event.type === "done") break;
-  }
-  if (assistantContent.length === 0) return [];
-  try {
-    await addMessage(conversationId, "assistant", agentName, assistantContent);
-  } catch (err) {
-    console.error(`[chat] failed to persist conversation message from ${agentName}:`, err);
-  }
-  return assistantContent;
-}
-var app11 = new Hono11().post("/:name/chat", zValidator4("json", chatSchema), async (c) => {
+var app11 = new Hono11().post("/:name/chat", zValidator3("json", chatSchema), async (c) => {
   const name = c.req.param("name");
   const [baseName] = name.split("@", 2);
   const entry = findAgent(baseName);
@@ -1991,7 +1940,6 @@ var app11 = new Hono11().post("/:name/chat", zValidator4("json", chatSchema), as
       return c.json({ error: "Conversation not found" }, 404);
     }
   } else {
-    const title = body.message ? body.message.slice(0, 80) : "Image message";
     const participantIds = [];
     if (user.id !== 0) {
       participantIds.push(user.id);
@@ -2010,6 +1958,8 @@ var app11 = new Hono11().post("/:name/chat", zValidator4("json", chatSchema), as
       }
     }
     if (!conversationId) {
+      const participantNames2 = /* @__PURE__ */ new Set([senderName, baseName]);
+      const title = [...participantNames2].join(", ");
       const conv2 = await createConversation(baseName, "volute", {
         userId: user.id !== 0 ? user.id : void 0,
         title,
@@ -2034,108 +1984,86 @@ var app11 = new Hono11().post("/:name/chat", zValidator4("json", chatSchema), as
   const participants = await getParticipants(conversationId);
   const agentParticipants = participants.filter((p) => p.userType === "agent");
   const participantNames = participants.map((p) => p.username);
-  const { getAgentManager: getAgentManager2 } = await import("./agent-manager-IMZ7ZMBF.js");
+  const { getAgentManager: getAgentManager2 } = await import("./agent-manager-CMMH5KQQ.js");
   const manager = getAgentManager2();
   const runningAgents = agentParticipants.map((ap) => {
     const agentKey = ap.username === baseName ? name : ap.username;
     return manager.isRunning(agentKey) ? ap.username : null;
   }).filter((n) => n !== null && n !== senderName);
   const isDM = participants.length === 2;
-  const dir = agentDir(baseName);
-  writeChannelEntry(dir, channel, {
+  const channelEntry = {
     platformId: conversationId,
     platform: "volute",
     name: convTitle ?? void 0,
     type: isDM ? "dm" : "group"
-  });
+  };
+  for (const ap of agentParticipants) {
+    try {
+      writeChannelEntry(ap.username, channel, channelEntry);
+    } catch (err) {
+      console.warn(`[chat] failed to write channel entry for ${ap.username}:`, err);
+    }
+  }
   const typingMap = getTypingMap();
   const currentlyTyping = typingMap.get(channel);
   const payload = JSON.stringify({
     content: contentBlocks,
     channel,
+    conversationId,
     sender: senderName,
     participants: participantNames,
     participantCount: participants.length,
     isDM,
     ...currentlyTyping.length > 0 ? { typing: currentlyTyping } : {}
   });
-  const responses = [];
   for (const agentName of runningAgents) {
     const targetName = agentName === baseName ? name : agentName;
-    try {
-      const res = await daemonFetchInternal(
-        `/api/agents/${encodeURIComponent(targetName)}/message`,
-        payload
-      );
-      if (res.ok && res.body) {
-        responses.push({ name: agentName, res });
-      } else {
-        const errorBody = await res.text().catch(() => "");
-        console.error(
-          `[chat] agent ${agentName} responded with ${res.status}: ${errorBody.slice(0, 500)}`
-        );
+    daemonFetchInternal(`/api/agents/${encodeURIComponent(targetName)}/message`, payload).then(async (res) => {
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        console.error(`[chat] agent ${agentName} responded ${res.status}: ${text}`);
       }
-    } catch (err) {
+    }).catch((err) => {
       console.error(`[chat] agent ${agentName} unreachable via daemon:`, err);
-    }
-  }
-  if (responses.length === 0) {
-    return streamSSE3(c, async (stream2) => {
-      await stream2.writeSSE({
-        data: JSON.stringify({ type: "meta", conversationId })
-      });
-      await stream2.writeSSE({ data: JSON.stringify({ type: "sync" }) });
     });
   }
-  const primary = responses[0];
-  const secondary = responses.slice(1);
-  const secondaryPromises = secondary.map((s) => consumeAndPersist(s.res, conversationId, s.name));
-  return streamSSE3(c, async (stream2) => {
-    await stream2.writeSSE({
-      data: JSON.stringify({ type: "meta", conversationId, senderName: primary.name })
+  return c.json({ ok: true, conversationId });
+}).get("/:name/conversations/:id/events", async (c) => {
+  const conversationId = c.req.param("id");
+  const user = c.get("user");
+  if (user.id !== 0 && !await isParticipantOrOwner(conversationId, user.id)) {
+    return c.json({ error: "Conversation not found" }, 404);
+  }
+  return streamSSE3(c, async (stream) => {
+    const unsubscribe = subscribe(conversationId, (event) => {
+      stream.writeSSE({ data: JSON.stringify(event) }).catch((err) => {
+        if (!stream.aborted) console.error("[chat] SSE write error:", err);
+      });
     });
-    const assistantContent = [];
-    try {
-      for await (const event of readNdjson(primary.res.body)) {
-        await stream2.writeSSE({ data: JSON.stringify(event) });
-        accumulateEvent(assistantContent, event);
-        if (event.type === "done") break;
-      }
-    } catch (err) {
-      console.error(`[chat] error streaming response from ${primary.name}:`, err);
-      await stream2.writeSSE({
-        data: JSON.stringify({ type: "error", message: "Stream interrupted" })
+    const keepAlive = setInterval(() => {
+      stream.writeSSE({ data: "" }).catch((err) => {
+        if (!stream.aborted) console.error("[chat] SSE ping error:", err);
       });
-    }
-    if (assistantContent.length > 0) {
-      try {
-        await addMessage(conversationId, "assistant", primary.name, assistantContent);
-      } catch (err) {
-        console.error(`[chat] failed to persist response from ${primary.name}:`, err);
-      }
-    }
-    const results = await Promise.allSettled(secondaryPromises);
-    for (let i = 0; i < results.length; i++) {
-      if (results[i].status === "rejected") {
-        console.error(
-          `[chat] secondary agent ${secondary[i].name} response failed:`,
-          results[i].reason
-        );
-      }
-    }
-    await stream2.writeSSE({ data: JSON.stringify({ type: "sync" }) });
+    }, 15e3);
+    await new Promise((resolve11) => {
+      stream.onAbort(() => {
+        unsubscribe();
+        clearInterval(keepAlive);
+        resolve11();
+      });
+    });
   });
 });
 var chat_default = app11;
 
 // src/web/routes/volute/conversations.ts
-import { zValidator as zValidator5 } from "@hono/zod-validator";
+import { zValidator as zValidator4 } from "@hono/zod-validator";
 import { Hono as Hono12 } from "hono";
-import { z as z5 } from "zod";
-var createConvSchema = z5.object({
-  title: z5.string().optional(),
-  participantIds: z5.array(z5.number()).optional(),
-  participantNames: z5.array(z5.string()).optional()
+import { z as z4 } from "zod";
+var createConvSchema = z4.object({
+  title: z4.string().optional(),
+  participantIds: z4.array(z4.number()).optional(),
+  participantNames: z4.array(z4.string()).optional()
 });
 var app12 = new Hono12().get("/:name/conversations", async (c) => {
   const name = c.req.param("name");
@@ -2148,7 +2076,7 @@ var app12 = new Hono12().get("/:name/conversations", async (c) => {
   const all = await listConversationsForUser(lookupId);
   const convs = all.filter((c2) => c2.agent_name === name);
   return c.json(convs);
-}).post("/:name/conversations", zValidator5("json", createConvSchema), async (c) => {
+}).post("/:name/conversations", zValidator4("json", createConvSchema), async (c) => {
   const name = c.req.param("name");
   const user = c.get("user");
   const body = c.req.valid("json");
@@ -2189,9 +2117,13 @@ var app12 = new Hono12().get("/:name/conversations", async (c) => {
       console.warn(`[conversations] DM conversation ${existingId} found but not retrievable`);
     }
   }
+  let title = body.title;
+  if (!title && body.participantNames?.length) {
+    title = body.participantNames.join(", ");
+  }
   const conv = await createConversation(name, "volute", {
     userId: user.id !== 0 ? user.id : void 0,
-    title: body.title,
+    title,
     participantIds
   });
   return c.json(conv, 201);
@@ -2221,12 +2153,12 @@ var app12 = new Hono12().get("/:name/conversations", async (c) => {
 var conversations_default = app12;
 
 // src/web/routes/volute/user-conversations.ts
-import { zValidator as zValidator6 } from "@hono/zod-validator";
+import { zValidator as zValidator5 } from "@hono/zod-validator";
 import { Hono as Hono13 } from "hono";
-import { z as z6 } from "zod";
-var createSchema = z6.object({
-  title: z6.string().optional(),
-  participantNames: z6.array(z6.string()).min(1)
+import { z as z5 } from "zod";
+var createSchema = z5.object({
+  title: z5.string().optional(),
+  participantNames: z5.array(z5.string()).min(1)
 });
 var app13 = new Hono13().use("*", authMiddleware).get("/", async (c) => {
   const user = c.get("user");
@@ -2240,7 +2172,7 @@ var app13 = new Hono13().use("*", authMiddleware).get("/", async (c) => {
   }
   const msgs = await getMessages(id);
   return c.json(msgs);
-}).post("/", zValidator6("json", createSchema), async (c) => {
+}).post("/", zValidator5("json", createSchema), async (c) => {
   const user = c.get("user");
   const body = c.req.valid("json");
   const participantIds = /* @__PURE__ */ new Set();
@@ -2346,8 +2278,8 @@ async function startServer({
   let assetsDir = "";
   let searchDir = dirname2(new URL(import.meta.url).pathname);
   for (let i = 0; i < 5; i++) {
-    const candidate = resolve8(searchDir, "dist", "web-assets");
-    if (existsSync6(candidate)) {
+    const candidate = resolve9(searchDir, "dist", "web-assets");
+    if (existsSync7(candidate)) {
       assetsDir = candidate;
       break;
     }
@@ -2357,7 +2289,7 @@ async function startServer({
     app_default.get("*", async (c) => {
       const urlPath = new URL(c.req.url).pathname;
       if (urlPath.startsWith("/api/")) return c.notFound();
-      const filePath = resolve8(assetsDir, urlPath.slice(1));
+      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()) {
@@ -2366,7 +2298,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");
@@ -2376,10 +2308,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);
@@ -2390,14 +2322,14 @@ async function startServer({
 
 // src/daemon.ts
 if (!process.env.VOLUTE_HOME) {
-  process.env.VOLUTE_HOME = resolve9(homedir(), ".volute");
+  process.env.VOLUTE_HOME = resolve10(homedir(), ".volute");
 }
 async function startDaemon(opts) {
   const { port, hostname } = opts;
   const myPid = String(process.pid);
   const home = voluteHome();
   if (!opts.foreground) {
-    const log2 = new RotatingLog(resolve9(home, "daemon.log"));
+    const log2 = new RotatingLog(resolve10(home, "daemon.log"));
     const write2 = (...args) => log2.write(`${format(...args)}
 `);
     console.log = write2;
@@ -2405,11 +2337,12 @@ async function startDaemon(opts) {
     console.warn = write2;
     console.info = write2;
   }
-  const DAEMON_PID_PATH = resolve9(home, "daemon.pid");
-  const DAEMON_JSON_PATH = resolve9(home, "daemon.json");
-  mkdirSync2(home, { recursive: true });
+  const DAEMON_PID_PATH = resolve10(home, "daemon.pid");
+  const DAEMON_JSON_PATH = resolve10(home, "daemon.json");
+  mkdirSync3(home, { recursive: true });
   const token = process.env.VOLUTE_DAEMON_TOKEN || randomBytes(32).toString("hex");
   process.env.VOLUTE_DAEMON_TOKEN = token;
+  process.env.VOLUTE_DAEMON_PORT = String(port);
   process.env.VOLUTE_DAEMON_HOSTNAME = hostname;
   let server;
   try {
@@ -2435,6 +2368,13 @@ async function startDaemon(opts) {
   const tokenBudget = getTokenBudget();
   tokenBudget.start(port, token);
   const registry = readRegistry();
+  for (const entry of registry) {
+    try {
+      migrateAgentState(entry.name);
+    } catch (err) {
+      console.error(`[daemon] failed to migrate state for ${entry.name}:`, err);
+    }
+  }
   for (const entry of registry) {
     if (!entry.running) continue;
     try {