volute 0.11.4 → 0.13.0

package/dist/daemon.js

@@ -1,4 +1,11 @@
 #!/usr/bin/env node
+import {
+  applyInitFiles,
+  composeTemplate,
+  copyTemplateToDir,
+  findTemplatesRoot,
+  listFiles
+} from "./chunk-XUA3JUFK.js";
 import {
   RotatingLog,
   clearJsonMap,
@@ -6,16 +13,7 @@ import {
   initAgentManager,
   loadJsonMap,
   saveJsonMap
-} from "./chunk-YTOPX4PB.js";
-import {
-  applyIsolation,
-  chownAgentDir,
-  createAgentUser,
-  deleteAgentUser,
-  ensureVoluteGroup,
-  getAgentUserIds,
-  isIsolationEnabled
-} from "./chunk-46S7YHUB.js";
+} from "./chunk-NQKKTRET.js";
 import {
   findOpenClawSession,
   importOpenClawConnectors,
@@ -23,33 +21,41 @@ import {
   parseNameFromIdentity,
   readVoluteConfig,
   writeVoluteConfig
-} from "./chunk-R3VB7NF5.js";
+} from "./chunk-KYHC7LHS.js";
 import {
   agentEnvPath,
   loadMergedEnv,
   readEnv,
   sharedEnvPath,
   writeEnv
-} from "./chunk-QF22MYDJ.js";
+} from "./chunk-BJDLYTPS.js";
 import {
   CHANNELS,
   getChannelDriver
-} from "./chunk-LIPPXNIE.js";
+} from "./chunk-PTK3GBCG.js";
 import {
   exec,
   gitExec,
   resolveVoluteBin
-} from "./chunk-WTJI3JVR.js";
+} from "./chunk-VRAOTXDF.js";
+import {
+  chownAgentDir,
+  createAgentUser,
+  deleteAgentUser,
+  ensureVoluteGroup,
+  isIsolationEnabled,
+  wrapForIsolation
+} from "./chunk-EN3NHRQC.js";
 import {
   checkForUpdate,
   checkForUpdateCached,
   getCurrentVersion
-} from "./chunk-YY2QX2J6.js";
+} from "./chunk-LG4ROCHN.js";
 import "./chunk-D424ZQGI.js";
 import {
-  slugify,
+  buildVoluteSlug,
   writeChannelEntry
-} from "./chunk-N6MLQ26B.js";
+} from "./chunk-GPZCPGV3.js";
 import {
   addAgent,
   addVariant,
@@ -72,16 +78,16 @@ import {
   validateAgentName,
   validateBranchName,
   voluteHome
-} from "./chunk-DP2DX4WV.js";
+} from "./chunk-ESTOWEG2.js";
 import {
   __export
 } from "./chunk-K3NQKI34.js";
 
 // src/daemon.ts
 import { randomBytes } from "crypto";
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync9, unlinkSync as unlinkSync2, writeFileSync as writeFileSync7 } from "fs";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync8, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "fs";
 import { homedir as homedir2 } from "os";
-import { resolve as resolve16 } from "path";
+import { resolve as resolve15 } from "path";
 import { format } from "util";
 
 // src/lib/connector-manager.ts
@@ -248,8 +254,14 @@ var ConnectorManager = class {
     const logsDir = resolve2(agentStateDir, "logs");
     mkdirSync(logsDir, { recursive: true });
     if (isIsolationEnabled()) {
-      const [base] = agentName.split("@", 2);
-      chownAgentDir(agentStateDir, base);
+      try {
+        const [base] = agentName.split("@", 2);
+        chownAgentDir(agentStateDir, base);
+      } catch (err) {
+        throw new Error(
+          `Cannot start connector ${type} for ${agentName}: failed to set ownership on state directory ${agentStateDir}: ${err instanceof Error ? err.message : err}`
+        );
+      }
     }
     const logStream = new RotatingLog(resolve2(logsDir, `${type}.log`));
     const agentEnv = loadMergedEnv(agentName);
@@ -271,8 +283,8 @@ var ConnectorManager = class {
         ...connectorEnv
       }
     };
-    await applyIsolation(spawnOpts, agentName);
-    const child = spawn(runtime, [connectorScript], spawnOpts);
+    const [spawnCmd, spawnArgs] = wrapForIsolation(runtime, [connectorScript], agentName);
+    const child = spawn(spawnCmd, spawnArgs, spawnOpts);
     let lastStderr = "";
     child.stdout?.pipe(logStream);
     child.stderr?.on("data", (chunk) => {
@@ -326,19 +338,19 @@ var ConnectorManager = class {
     const stopKey = `${agentName}:${type}`;
     this.stopping.add(stopKey);
     agentMap.delete(type);
-    await new Promise((resolve17) => {
-      tracked.child.on("exit", () => resolve17());
+    await new Promise((resolve16) => {
+      tracked.child.on("exit", () => resolve16());
       try {
         tracked.child.kill("SIGTERM");
       } catch {
-        resolve17();
+        resolve16();
       }
       setTimeout(() => {
         try {
           tracked.child.kill("SIGKILL");
         } catch {
         }
-        resolve17();
+        resolve16();
       }, 5e3);
     });
     this.stopping.delete(stopKey);
@@ -1048,9 +1060,9 @@ var authMiddleware = createMiddleware(async (c, next) => {
 });
 
 // src/web/server.ts
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { readFile as readFile2, stat } from "fs/promises";
-import { dirname as dirname4, extname, resolve as resolve15 } from "path";
+import { dirname as dirname3, extname, resolve as resolve14 } from "path";
 import { serve } from "@hono/node-server";
 
 // src/lib/log-buffer.ts
@@ -1105,17 +1117,19 @@ import { HTTPException } from "hono/http-exception";
 
 // src/web/routes/agents.ts
 import {
-  cpSync as cpSync2,
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync5,
-  readdirSync as readdirSync4,
-  readFileSync as readFileSync6,
-  rmSync as rmSync2,
-  writeFileSync as writeFileSync5
+  cpSync,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync4,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync5,
+  rmSync,
+  writeFileSync as writeFileSync4
 } from "fs";
-import { resolve as resolve9 } from "path";
-import { and as and2, desc, eq as eq3 } from "drizzle-orm";
+import { resolve as resolve8 } from "path";
+import { zValidator } from "@hono/zod-validator";
+import { and as and3, desc as desc2, eq as eq4, sql as sql3 } from "drizzle-orm";
 import { Hono } from "hono";
+import { z } from "zod";
 
 // src/lib/consolidate.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
@@ -1188,14 +1202,209 @@ ${content2}`);
   }
 }
 
-// src/lib/convert-session.ts
+// src/lib/conversations.ts
 import { randomUUID } from "crypto";
+import { and as and2, desc, eq as eq3, inArray, isNull, sql as sql2 } from "drizzle-orm";
+
+// 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
+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(eq3(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, eq3(conversationParticipants.user_id, users.id)).where(eq3(conversationParticipants.conversation_id, conversationId)).all();
+  return rows;
+}
+async function isParticipant(conversationId, userId) {
+  const db2 = await getDb();
+  const row = await db2.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(
+    and2(
+      eq3(conversationParticipants.conversation_id, conversationId),
+      eq3(conversationParticipants.user_id, userId)
+    )
+  ).get();
+  return row != null;
+}
+async function listConversationsForUser(userId) {
+  const db2 = await getDb();
+  const participantRows = await db2.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(eq3(conversationParticipants.user_id, userId)).all();
+  if (participantRows.length === 0) return [];
+  const convIds = participantRows.map((r) => r.conversation_id);
+  return db2.select().from(conversations).where(inArray(conversations.id, convIds)).orderBy(desc(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(and2(eq3(conversations.id, conversationId), eq3(conversations.user_id, userId))).get();
+  return row != null;
+}
+async function deleteConversationForUser(id, userId) {
+  if (!await isParticipantOrOwner(id, userId)) return false;
+  await deleteConversation(id);
+  return true;
+}
+async function addMessage(conversationId, role, senderName, content) {
+  const db2 = await getDb();
+  const 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(eq3(conversations.id, conversationId));
+  if (role === "user") {
+    const firstText = content.find((b) => b.type === "text");
+    const title = firstText ? firstText.text.slice(0, 80) : "";
+    if (title) {
+      await db2.update(conversations).set({ title }).where(and2(eq3(conversations.id, conversationId), isNull(conversations.title)));
+    }
+  }
+  const msg = {
+    id: result.id,
+    conversation_id: conversationId,
+    role,
+    sender_name: senderName,
+    content,
+    created_at: result.created_at
+  };
+  publish(conversationId, {
+    type: "message",
+    id: msg.id,
+    role: msg.role,
+    senderName: msg.sender_name,
+    content: msg.content,
+    createdAt: msg.created_at
+  });
+  return msg;
+}
+async function getMessages(conversationId) {
+  const db2 = await getDb();
+  const rows = await db2.select().from(messages).where(eq3(messages.conversation_id, conversationId)).orderBy(messages.created_at).all();
+  return rows.map((row) => {
+    let content;
+    try {
+      const parsed = JSON.parse(row.content);
+      content = Array.isArray(parsed) ? parsed : [{ type: "text", text: row.content }];
+    } catch {
+      content = [{ type: "text", text: row.content }];
+    }
+    return { ...row, content };
+  });
+}
+async function listConversationsWithParticipants(userId) {
+  const convs = await listConversationsForUser(userId);
+  if (convs.length === 0) return [];
+  const db2 = await getDb();
+  const convIds = convs.map((c) => c.id);
+  const rows = await db2.select({
+    conversationId: conversationParticipants.conversation_id,
+    userId: users.id,
+    username: users.username,
+    userType: users.user_type,
+    role: conversationParticipants.role
+  }).from(conversationParticipants).innerJoin(users, eq3(conversationParticipants.user_id, users.id)).where(inArray(conversationParticipants.conversation_id, convIds));
+  const byConv = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    let arr = byConv.get(r.conversationId);
+    if (!arr) {
+      arr = [];
+      byConv.set(r.conversationId, arr);
+    }
+    arr.push({
+      userId: r.userId,
+      username: r.username,
+      userType: r.userType,
+      role: r.role
+    });
+  }
+  return convs.map((c) => ({ ...c, participants: byConv.get(c.id) ?? [] }));
+}
+async function findDMConversation(agentName, participantIds) {
+  const db2 = await getDb();
+  const agentConvs = await db2.select({ id: conversations.id }).from(conversations).where(eq3(conversations.agent_name, agentName)).all();
+  for (const conv of agentConvs) {
+    const rows = await db2.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(eq3(conversationParticipants.conversation_id, conv.id)).all();
+    if (rows.length !== 2) continue;
+    const ids = new Set(rows.map((r) => r.user_id));
+    if (ids.has(participantIds[0]) && ids.has(participantIds[1])) {
+      return conv.id;
+    }
+  }
+  return null;
+}
+async function deleteConversation(id) {
+  const db2 = await getDb();
+  await db2.delete(conversations).where(eq3(conversations.id, id));
+}
+
+// src/lib/convert-session.ts
+import { randomUUID as randomUUID2 } from "crypto";
 import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
 import { homedir } from "os";
 import { resolve as resolve7 } from "path";
 function convertSession(opts) {
   const lines = readFileSync4(opts.sessionPath, "utf-8").trim().split("\n");
-  const sessionId = randomUUID();
+  const sessionId = randomUUID2();
   const idMap = /* @__PURE__ */ new Map();
   const messages2 = [];
   for (const line of lines) {
@@ -1210,7 +1419,7 @@ function convertSession(opts) {
     const event = messages2[i];
     const msg = event.message;
     if (msg.role === "user") {
-      const uuid = randomUUID();
+      const uuid = randomUUID2();
       idMap.set(event.id, uuid);
       const parentUuid = event.parentId ? idMap.get(event.parentId) ?? null : null;
       const sdkEvent = {
@@ -1234,7 +1443,7 @@ function convertSession(opts) {
     } else if (msg.role === "assistant") {
       const content = convertAssistantContent(msg.content);
       if (content.length === 0) continue;
-      const uuid = randomUUID();
+      const uuid = randomUUID2();
       idMap.set(event.id, uuid);
       const parentUuid = event.parentId ? idMap.get(event.parentId) ?? null : null;
       const stopReason = mapStopReason(msg.stopReason);
@@ -1249,12 +1458,12 @@ function convertSession(opts) {
         isSidechain: false,
         userType: "external",
         type: "assistant",
-        requestId: `req_imported_${randomUUID()}`,
+        requestId: `req_imported_${randomUUID2()}`,
         message: {
           role: "assistant",
           content,
           type: "message",
-          id: `msg_imported_${randomUUID()}`,
+          id: `msg_imported_${randomUUID2()}`,
           model: mapModel(msg.model),
           stop_reason: stopReason,
           stop_sequence: null,
@@ -1282,7 +1491,7 @@ function convertSession(opts) {
         j++;
       }
       i = j - 1;
-      const uuid = randomUUID();
+      const uuid = randomUUID2();
       idMap.set(lastToolResultId, uuid);
       const parentUuid = event.parentId ? idMap.get(event.parentId) ?? null : lastSdkUuid;
       const sdkEvent = {
@@ -1362,118 +1571,6 @@ function convertAssistantContent(content) {
   return result;
 }
 
-// src/lib/template.ts
-import {
-  cpSync,
-  existsSync as existsSync5,
-  mkdirSync as mkdirSync4,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync5,
-  renameSync,
-  rmSync,
-  statSync,
-  writeFileSync as writeFileSync4
-} from "fs";
-import { tmpdir } from "os";
-import { dirname as dirname3, join, relative, resolve as resolve8 } from "path";
-function findTemplatesRoot() {
-  let dir = dirname3(new URL(import.meta.url).pathname);
-  for (let i = 0; i < 5; i++) {
-    const candidate = resolve8(dir, "templates");
-    if (existsSync5(resolve8(candidate, "_base"))) return candidate;
-    dir = dirname3(dir);
-  }
-  console.error(
-    "Templates directory not found. Searched up from:",
-    dirname3(new URL(import.meta.url).pathname)
-  );
-  process.exit(1);
-}
-function composeTemplate(templatesRoot, templateName) {
-  const baseDir = resolve8(templatesRoot, "_base");
-  const templateDir = resolve8(templatesRoot, templateName);
-  if (!existsSync5(baseDir)) {
-    console.error("Base template not found:", baseDir);
-    process.exit(1);
-  }
-  if (!existsSync5(templateDir)) {
-    console.error(`Template not found: ${templateName}`);
-    process.exit(1);
-  }
-  const composedDir = resolve8(tmpdir(), `volute-template-${Date.now()}`);
-  mkdirSync4(composedDir, { recursive: true });
-  cpSync(baseDir, composedDir, { recursive: true });
-  for (const file of listFiles(templateDir)) {
-    const src = resolve8(templateDir, file);
-    const dest = resolve8(composedDir, file);
-    mkdirSync4(dirname3(dest), { recursive: true });
-    cpSync(src, dest);
-  }
-  const manifestPath = resolve8(composedDir, "volute-template.json");
-  if (!existsSync5(manifestPath)) {
-    rmSync(composedDir, { recursive: true, force: true });
-    console.error(`Template manifest not found: ${templateName}/volute-template.json`);
-    process.exit(1);
-  }
-  const manifest = JSON.parse(readFileSync5(manifestPath, "utf-8"));
-  const skillsSrc = resolve8(composedDir, "_skills");
-  if (existsSync5(skillsSrc)) {
-    const skillsDest = resolve8(composedDir, manifest.skillsDir);
-    mkdirSync4(skillsDest, { recursive: true });
-    cpSync(skillsSrc, skillsDest, { recursive: true });
-    rmSync(skillsSrc, { recursive: true, force: true });
-  }
-  rmSync(manifestPath);
-  return { composedDir, manifest };
-}
-function copyTemplateToDir(composedDir, destDir, agentName, manifest) {
-  cpSync(composedDir, destDir, { recursive: true });
-  for (const [from, to] of Object.entries(manifest.rename)) {
-    const fromPath = resolve8(destDir, from);
-    if (existsSync5(fromPath)) {
-      renameSync(fromPath, resolve8(destDir, to));
-    }
-  }
-  for (const file of manifest.substitute) {
-    const path = resolve8(destDir, file);
-    if (existsSync5(path)) {
-      const content = readFileSync5(path, "utf-8");
-      writeFileSync4(path, content.replaceAll("{{name}}", agentName));
-    }
-  }
-}
-function applyInitFiles(destDir) {
-  const initDir = resolve8(destDir, ".init");
-  if (!existsSync5(initDir)) return;
-  const homeDir = resolve8(destDir, "home");
-  for (const file of listFiles(initDir)) {
-    const src = resolve8(initDir, file);
-    const dest = resolve8(homeDir, file);
-    const parent = dirname3(dest);
-    if (!existsSync5(parent)) {
-      mkdirSync4(parent, { recursive: true });
-    }
-    cpSync(src, dest);
-  }
-  rmSync(initDir, { recursive: true, force: true });
-}
-function listFiles(dir) {
-  const results = [];
-  function walk(current) {
-    for (const entry of readdirSync3(current)) {
-      const full = join(current, entry);
-      if (statSync(full).isDirectory()) {
-        if (entry === ".git") continue;
-        walk(full);
-      } else {
-        results.push(relative(dir, full));
-      }
-    }
-  }
-  walk(dir);
-  return results;
-}
-
 // src/lib/typing.ts
 var DEFAULT_TTL_MS = 1e4;
 var SWEEP_INTERVAL_MS = 5e3;
@@ -1545,6 +1642,7 @@ function getTypingMap() {
 async function startAgentFull(name, baseName, variantName) {
   await getAgentManager().startAgent(name);
   if (variantName) return;
+  if (findAgent(baseName)?.stage === "seed") return;
   const dir = agentDir(baseName);
   const entry = findAgent(baseName);
   await getConnectorManager().startConnectors(baseName, dir, entry.port, getDaemonPort());
@@ -1567,7 +1665,7 @@ function extractTextContent(content) {
 }
 function getDaemonPort() {
   try {
-    const data = JSON.parse(readFileSync6(resolve9(voluteHome(), "daemon.json"), "utf-8"));
+    const data = JSON.parse(readFileSync5(resolve8(voluteHome(), "daemon.json"), "utf-8"));
     return data.port;
   } catch (err) {
     if (err?.code !== "ENOENT") {
@@ -1607,9 +1705,9 @@ async function getAgentStatus(name, port) {
   return { status, channels };
 }
 var TEMPLATE_BRANCH = "volute/template";
-async function initTemplateBranch(projectRoot, composedDir, manifest, ids, env) {
+async function initTemplateBranch(projectRoot, composedDir, manifest, agentName, env) {
   const templateFiles = listFiles(composedDir).filter((f) => !f.startsWith(".init/") && !f.startsWith(".init\\")).map((f) => manifest.rename[f] ?? f);
-  const opts = { cwd: projectRoot, uid: ids?.uid, gid: ids?.gid, env };
+  const opts = { cwd: projectRoot, agentName, env };
   await gitExec(["checkout", "--orphan", TEMPLATE_BRANCH], opts);
   await gitExec(["add", "--", ...templateFiles], opts);
   await gitExec(["commit", "-m", "template update"], opts);
@@ -1618,7 +1716,7 @@ async function initTemplateBranch(projectRoot, composedDir, manifest, ids, env)
   await gitExec(["commit", "-m", "initial commit"], opts);
 }
 async function updateTemplateBranch(projectRoot, template, agentName) {
-  const tempWorktree = resolve9(projectRoot, ".variants", "_template_update");
+  const tempWorktree = resolve8(projectRoot, ".variants", "_template_update");
   let branchExists = false;
   try {
     await gitExec(["rev-parse", "--verify", TEMPLATE_BRANCH], { cwd: projectRoot });
@@ -1629,8 +1727,8 @@ async function updateTemplateBranch(projectRoot, template, agentName) {
     await gitExec(["worktree", "remove", "--force", tempWorktree], { cwd: projectRoot });
   } catch {
   }
-  if (existsSync6(tempWorktree)) {
-    rmSync2(tempWorktree, { recursive: true, force: true });
+  if (existsSync5(tempWorktree)) {
+    rmSync(tempWorktree, { recursive: true, force: true });
   }
   const templatesRoot = findTemplatesRoot();
   const { composedDir, manifest } = composeTemplate(templatesRoot, template);
@@ -1650,9 +1748,9 @@ async function updateTemplateBranch(projectRoot, template, agentName) {
       });
     }
     copyTemplateToDir(composedDir, tempWorktree, agentName, manifest);
-    const initDir = resolve9(tempWorktree, ".init");
-    if (existsSync6(initDir)) {
-      rmSync2(initDir, { recursive: true, force: true });
+    const initDir = resolve8(tempWorktree, ".init");
+    if (existsSync5(initDir)) {
+      rmSync(initDir, { recursive: true, force: true });
     }
     await gitExec(["add", "-A"], { cwd: tempWorktree });
     try {
@@ -1665,10 +1763,10 @@ async function updateTemplateBranch(projectRoot, template, agentName) {
       await gitExec(["worktree", "remove", "--force", tempWorktree], { cwd: projectRoot });
     } catch {
     }
-    if (existsSync6(tempWorktree)) {
-      rmSync2(tempWorktree, { recursive: true, force: true });
+    if (existsSync5(tempWorktree)) {
+      rmSync(tempWorktree, { recursive: true, force: true });
     }
-    rmSync2(composedDir, { recursive: true, force: true });
+    rmSync(composedDir, { recursive: true, force: true });
   }
 }
 async function mergeTemplateBranch(worktreeDir) {
@@ -1688,57 +1786,87 @@ async function mergeTemplateBranch(worktreeDir) {
     throw e;
   }
 }
-var app = new Hono().post("/", requireAdmin, async (c) => {
-  let body;
-  try {
-    body = await c.req.json();
-  } catch {
-    return c.json({ error: "Invalid JSON" }, 400);
-  }
+var createAgentSchema = z.object({
+  name: z.string(),
+  template: z.string().optional(),
+  stage: z.enum(["seed", "mind"]).optional(),
+  description: z.string().optional(),
+  model: z.string().optional()
+});
+var app = new Hono().post("/", requireAdmin, zValidator("json", createAgentSchema), async (c) => {
+  const body = c.req.valid("json");
   const { name, template = "agent-sdk" } = body;
   const nameErr = validateAgentName(name);
   if (nameErr) return c.json({ error: nameErr }, 400);
   if (findAgent(name)) return c.json({ error: `Agent already exists: ${name}` }, 409);
   ensureVoluteHome();
   const dest = agentDir(name);
-  if (existsSync6(dest)) return c.json({ error: "Agent directory already exists" }, 409);
+  if (existsSync5(dest)) return c.json({ error: "Agent directory already exists" }, 409);
   const templatesRoot = findTemplatesRoot();
   const { composedDir, manifest } = composeTemplate(templatesRoot, template);
   try {
     copyTemplateToDir(composedDir, dest, name, manifest);
     applyInitFiles(dest);
+    if (body.model) {
+      const configPath = resolve8(dest, "home/.config/config.json");
+      const existing = existsSync5(configPath) ? JSON.parse(readFileSync5(configPath, "utf-8")) : {};
+      existing.model = body.model;
+      writeFileSync4(configPath, `${JSON.stringify(existing, null, 2)}
+`);
+    }
+    if (body.stage === "seed") {
+      const descLine = body.description ? `
+The human who planted you described you as: "${body.description}"
+` : "";
+      writeFileSync4(
+        resolve8(dest, "home/SOUL.md"),
+        `You are ${name}.
+
+You don't have a soul yet. You're a seed \u2014 a new agent in the process of discovering who you are.
+${descLine}
+Have a conversation with the human. Explore what kind of agent you want to be. When you're ready, write your SOUL.md and MEMORY.md, then run \`volute sprout\` to complete the transformation.
+`
+      );
+      const skillsDir = resolve8(dest, manifest.skillsDir);
+      for (const skill of ["volute-agent", "memory", "sessions"]) {
+        const skillPath = resolve8(skillsDir, skill);
+        if (existsSync5(skillPath)) rmSync(skillPath, { recursive: true, force: true });
+      }
+    }
     const port = nextPort();
-    addAgent(name, port);
+    addAgent(name, port, body.stage);
+    const homeDir = resolve8(dest, "home");
     ensureVoluteGroup();
-    createAgentUser(name);
+    createAgentUser(name, homeDir);
     chownAgentDir(dest, name);
-    const ids = isIsolationEnabled() ? await getAgentUserIds(name) : void 0;
-    const env = ids ? { ...process.env, HOME: dest } : void 0;
-    await exec("npm", ["install"], { cwd: dest, uid: ids?.uid, gid: ids?.gid, env });
+    const agentName = isIsolationEnabled() ? name : void 0;
+    const env = agentName ? { ...process.env, HOME: homeDir } : void 0;
+    await exec("npm", ["install"], { cwd: dest, agentName, env });
     let gitWarning;
     try {
-      await gitExec(["init"], { cwd: dest, uid: ids?.uid, gid: ids?.gid, env });
-      await initTemplateBranch(dest, composedDir, manifest, ids, env);
+      await gitExec(["init"], { cwd: dest, agentName, env });
+      await initTemplateBranch(dest, composedDir, manifest, agentName, env);
     } catch {
-      rmSync2(resolve9(dest, ".git"), { recursive: true, force: true });
+      rmSync(resolve8(dest, ".git"), { recursive: true, force: true });
       gitWarning = "Git setup failed \u2014 variants and upgrades won't be available until git is initialized.";
     }
     return c.json({
       ok: true,
       name,
       port,
+      stage: body.stage ?? "mind",
       message: `Created agent: ${name} (port ${port})`,
       ...gitWarning && { warning: gitWarning }
     });
   } catch (err) {
-    if (existsSync6(dest)) rmSync2(dest, { recursive: true, force: true });
+    if (existsSync5(dest)) rmSync(dest, { recursive: true, force: true });
     try {
       removeAgent(name);
     } catch {
     }
     return c.json({ error: err instanceof Error ? err.message : "Failed to create agent" }, 500);
   } finally {
-    rmSync2(composedDir, { recursive: true, force: true });
+    rmSync(composedDir, { recursive: true, force: true });
   }
 }).post("/import", requireAdmin, async (c) => {
   let body;
@@ -1748,13 +1876,13 @@ var app = new Hono().post("/", requireAdmin, async (c) => {
     return c.json({ error: "Invalid JSON" }, 400);
   }
   const wsDir = body.workspacePath;
-  if (!wsDir || !existsSync6(resolve9(wsDir, "SOUL.md")) || !existsSync6(resolve9(wsDir, "IDENTITY.md"))) {
+  if (!wsDir || !existsSync5(resolve8(wsDir, "SOUL.md")) || !existsSync5(resolve8(wsDir, "IDENTITY.md"))) {
     return c.json({ error: "Invalid workspace: missing SOUL.md or IDENTITY.md" }, 400);
   }
-  const soul = readFileSync6(resolve9(wsDir, "SOUL.md"), "utf-8");
-  const identity = readFileSync6(resolve9(wsDir, "IDENTITY.md"), "utf-8");
-  const userPath = resolve9(wsDir, "USER.md");
-  const user = existsSync6(userPath) ? readFileSync6(userPath, "utf-8") : "";
+  const soul = readFileSync5(resolve8(wsDir, "SOUL.md"), "utf-8");
+  const identity = readFileSync5(resolve8(wsDir, "IDENTITY.md"), "utf-8");
+  const userPath = resolve8(wsDir, "USER.md");
+  const user = existsSync5(userPath) ? readFileSync5(userPath, "utf-8") : "";
   const name = body.name ?? parseNameFromIdentity(identity) ?? "imported-agent";
   const template = body.template ?? "agent-sdk";
   const nameErr = validateAgentName(name);
@@ -1774,76 +1902,72 @@ ${user.trimEnd()}
 ` : "";
   ensureVoluteHome();
   const dest = agentDir(name);
-  if (existsSync6(dest)) return c.json({ error: "Agent directory already exists" }, 409);
+  if (existsSync5(dest)) return c.json({ error: "Agent directory already exists" }, 409);
   const templatesRoot = findTemplatesRoot();
   const { composedDir, manifest } = composeTemplate(templatesRoot, template);
   try {
     copyTemplateToDir(composedDir, dest, name, manifest);
     applyInitFiles(dest);
-    writeFileSync5(resolve9(dest, "home/SOUL.md"), mergedSoul);
-    const wsMemoryPath = resolve9(wsDir, "MEMORY.md");
-    const hasMemory = existsSync6(wsMemoryPath);
+    writeFileSync4(resolve8(dest, "home/SOUL.md"), mergedSoul);
+    const wsMemoryPath = resolve8(wsDir, "MEMORY.md");
+    const hasMemory = existsSync5(wsMemoryPath);
     if (hasMemory) {
-      const existingMemory = readFileSync6(wsMemoryPath, "utf-8");
-      writeFileSync5(
-        resolve9(dest, "home/MEMORY.md"),
+      const existingMemory = readFileSync5(wsMemoryPath, "utf-8");
+      writeFileSync4(
+        resolve8(dest, "home/MEMORY.md"),
         `${existingMemory.trimEnd()}${mergedMemoryExtra}`
       );
     } else if (user) {
-      writeFileSync5(resolve9(dest, "home/MEMORY.md"), `${user.trimEnd()}
+      writeFileSync4(resolve8(dest, "home/MEMORY.md"), `${user.trimEnd()}
 `);
     }
-    const wsMemoryDir = resolve9(wsDir, "memory");
+    const wsMemoryDir = resolve8(wsDir, "memory");
     let dailyLogCount = 0;
-    if (existsSync6(wsMemoryDir)) {
-      const destMemoryDir = resolve9(dest, "home/memory");
-      const files = readdirSync4(wsMemoryDir).filter((f) => f.endsWith(".md"));
+    if (existsSync5(wsMemoryDir)) {
+      const destMemoryDir = resolve8(dest, "home/memory");
+      const files = readdirSync3(wsMemoryDir).filter((f) => f.endsWith(".md"));
       for (const file of files) {
-        cpSync2(resolve9(wsMemoryDir, file), resolve9(destMemoryDir, file));
+        cpSync(resolve8(wsMemoryDir, file), resolve8(destMemoryDir, file));
       }
       dailyLogCount = files.length;
     }
     const port = nextPort();
     addAgent(name, port);
+    const homeDir = resolve8(dest, "home");
     ensureVoluteGroup();
-    createAgentUser(name);
+    createAgentUser(name, homeDir);
     chownAgentDir(dest, name);
-    const ids = isIsolationEnabled() ? await getAgentUserIds(name) : void 0;
-    const env = ids ? { ...process.env, HOME: dest } : void 0;
-    await exec("npm", ["install"], { cwd: dest, uid: ids?.uid, gid: ids?.gid, env });
+    const agentName = isIsolationEnabled() ? name : void 0;
+    const env = agentName ? { ...process.env, HOME: homeDir } : void 0;
+    await exec("npm", ["install"], { cwd: dest, agentName, env });
     if (!hasMemory && dailyLogCount > 0) {
       await consolidateMemory(dest);
     }
-    await gitExec(["init"], { cwd: dest, uid: ids?.uid, gid: ids?.gid, env });
-    await gitExec(["add", "-A"], { cwd: dest, uid: ids?.uid, gid: ids?.gid, env });
-    await gitExec(["commit", "-m", "import from OpenClaw"], {
-      cwd: dest,
-      uid: ids?.uid,
-      gid: ids?.gid,
-      env
-    });
-    const sessionFile = body.sessionPath ? resolve9(body.sessionPath) : findOpenClawSession(wsDir);
-    if (sessionFile && existsSync6(sessionFile)) {
+    await gitExec(["init"], { cwd: dest, agentName, env });
+    await gitExec(["add", "-A"], { cwd: dest, agentName, env });
+    await gitExec(["commit", "-m", "import from OpenClaw"], { cwd: dest, agentName, env });
+    const sessionFile = body.sessionPath ? resolve8(body.sessionPath) : findOpenClawSession(wsDir);
+    if (sessionFile && existsSync5(sessionFile)) {
       if (template === "pi") {
         importPiSession(sessionFile, dest);
       } else if (template === "agent-sdk") {
         const sessionId = convertSession({ sessionPath: sessionFile, projectDir: dest });
-        const voluteDir = resolve9(dest, ".volute");
-        mkdirSync5(voluteDir, { recursive: true });
-        writeFileSync5(resolve9(voluteDir, "session.json"), JSON.stringify({ sessionId }));
+        const voluteDir = resolve8(dest, ".volute");
+        mkdirSync4(voluteDir, { recursive: true });
+        writeFileSync4(resolve8(voluteDir, "session.json"), JSON.stringify({ sessionId }));
       }
     }
     importOpenClawConnectors(name, dest);
     return c.json({ ok: true, name, port, message: `Imported agent: ${name} (port ${port})` });
   } catch (err) {
-    if (existsSync6(dest)) rmSync2(dest, { recursive: true, force: true });
+    if (existsSync5(dest)) rmSync(dest, { recursive: true, force: true });
     try {
       removeAgent(name);
     } catch {
     }
     return c.json({ error: err instanceof Error ? err.message : "Failed to import agent" }, 500);
   } finally {
-    rmSync2(composedDir, { recursive: true, force: true });
+    rmSync(composedDir, { recursive: true, force: true });
   }
 }).get("/", async (c) => {
   const entries = readRegistry();
@@ -1858,7 +1982,7 @@ ${user.trimEnd()}
   const name = c.req.param("name");
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
-  if (!existsSync6(agentDir(name))) return c.json({ error: "Agent directory missing" }, 404);
+  if (!existsSync5(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();
@@ -1884,7 +2008,7 @@ ${user.trimEnd()}
     if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
   } else {
     const dir = agentDir(baseName);
-    if (!existsSync6(dir)) return c.json({ error: "Agent directory missing" }, 404);
+    if (!existsSync5(dir)) return c.json({ error: "Agent directory missing" }, 404);
   }
   if (getAgentManager().isRunning(name)) {
     return c.json({ error: "Agent already running" }, 409);
@@ -1905,7 +2029,7 @@ ${user.trimEnd()}
     if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
   } else {
     const dir = agentDir(baseName);
-    if (!existsSync6(dir)) return c.json({ error: "Agent directory missing" }, 404);
+    if (!existsSync5(dir)) return c.json({ error: "Agent directory missing" }, 404);
   }
   let context;
   const contentType = c.req.header("content-type");
@@ -1936,7 +2060,7 @@ ${user.trimEnd()}
       const variant = findVariant(baseName, mergeVariantName);
       if (variant) {
         const projectRoot = agentDir(baseName);
-        if (existsSync6(variant.path)) {
+        if (existsSync5(variant.path)) {
           const status = (await gitExec(["status", "--porcelain"], { cwd: variant.path })).trim();
           if (status) {
             try {
@@ -1964,7 +2088,7 @@ ${user.trimEnd()}
           }
         }
         await gitExec(["merge", variant.branch], { cwd: projectRoot });
-        if (existsSync6(variant.path)) {
+        if (existsSync5(variant.path)) {
           try {
             await gitExec(["worktree", "remove", "--force", variant.path], {
               cwd: projectRoot
@@ -1988,6 +2112,19 @@ ${user.trimEnd()}
     if (context) {
       manager.setPendingContext(name, context);
     }
+    if (context?.type === "sprouted" && !variantName) {
+      try {
+        const db2 = await getDb();
+        const activeConvs = await db2.select({ id: conversations.id }).from(conversations).where(eq4(conversations.agent_name, baseName)).all();
+        for (const conv of activeConvs) {
+          await addMessage(conv.id, "assistant", "system", [
+            { type: "text", text: "[seed has sprouted]" }
+          ]);
+        }
+      } catch (err) {
+        console.error(`[daemon] failed to inject sprouted message for ${baseName}:`, err);
+      }
+    }
     await startAgentFull(name, baseName, variantName);
     return c.json({ ok: true });
   } catch (err) {
@@ -2033,11 +2170,11 @@ ${user.trimEnd()}
   removeAgent(name);
   await deleteAgentUser2(name);
   const state = stateDir(name);
-  if (existsSync6(state)) {
-    rmSync2(state, { recursive: true, force: true });
+  if (existsSync5(state)) {
+    rmSync(state, { recursive: true, force: true });
   }
-  if (force && existsSync6(dir)) {
-    rmSync2(dir, { recursive: true, force: true });
+  if (force && existsSync5(dir)) {
+    rmSync(dir, { recursive: true, force: true });
     deleteAgentUser(name);
   }
   return c.json({ ok: true });
@@ -2046,7 +2183,7 @@ ${user.trimEnd()}
   const entry = findAgent(agentName);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(agentName);
-  if (!existsSync6(dir)) return c.json({ error: "Agent directory missing" }, 404);
+  if (!existsSync5(dir)) return c.json({ error: "Agent directory missing" }, 404);
   let body = {};
   try {
     body = await c.req.json();
@@ -2055,8 +2192,8 @@ ${user.trimEnd()}
   const template = body.template ?? "agent-sdk";
   const UPGRADE_VARIANT = "upgrade";
   if (body.continue) {
-    const worktreeDir2 = resolve9(dir, ".variants", UPGRADE_VARIANT);
-    if (!existsSync6(worktreeDir2)) {
+    const worktreeDir2 = resolve8(dir, ".variants", UPGRADE_VARIANT);
+    if (!existsSync5(worktreeDir2)) {
       return c.json({ error: "No upgrade in progress" }, 400);
     }
     const status = await gitExec(["status", "--porcelain"], { cwd: worktreeDir2 });
@@ -2116,8 +2253,8 @@ ${user.trimEnd()}
       );
     }
   }
-  const worktreeDir = resolve9(dir, ".variants", UPGRADE_VARIANT);
-  if (existsSync6(worktreeDir)) {
+  const worktreeDir = resolve8(dir, ".variants", UPGRADE_VARIANT);
+  if (existsSync5(worktreeDir)) {
     return c.json(
       { error: "Upgrade variant already exists. Use continue or delete it first." },
       409
@@ -2129,9 +2266,9 @@ ${user.trimEnd()}
   } catch {
   }
   await updateTemplateBranch(dir, template, agentName);
-  const parentDir = resolve9(dir, ".variants");
-  if (!existsSync6(parentDir)) {
-    mkdirSync5(parentDir, { recursive: true });
+  const parentDir = resolve8(dir, ".variants");
+  if (!existsSync5(parentDir)) {
+    mkdirSync4(parentDir, { recursive: true });
   }
   await gitExec(["worktree", "add", "-b", UPGRADE_VARIANT, worktreeDir], { cwd: dir });
   const hasConflicts = await mergeTemplateBranch(worktreeDir);
@@ -2258,6 +2395,24 @@ ${user.trimEnd()}
     budget.acknowledgeWarning(baseName);
     forwardBody = JSON.stringify(parsed);
   }
+  const seedEntry = findAgent(baseName);
+  if (seedEntry?.stage === "seed" && parsed) {
+    try {
+      const countResult = await db2.select({ count: sql3`count(*)` }).from(agentMessages).where(eq4(agentMessages.agent, baseName));
+      const msgCount = countResult[0]?.count ?? 0;
+      if (msgCount >= 10 && msgCount % 10 === 0) {
+        const nudge = "\n[You've been exploring for a while. Whenever you feel ready, write your SOUL.md and MEMORY.md, then run volute sprout.]";
+        if (typeof parsed.content === "string") {
+          parsed.content = parsed.content + nudge;
+        } else if (Array.isArray(parsed.content)) {
+          parsed.content = [...parsed.content, { type: "text", text: nudge }];
+        }
+        forwardBody = JSON.stringify(parsed);
+      }
+    } catch (err) {
+      console.error(`[daemon] failed to check seed message count for ${baseName}:`, err);
+    }
+  }
   typingMap.set(channel, baseName, { persistent: true });
   const conversationId = parsed?.conversationId ?? null;
   if (conversationId) typingMap.set(`volute:${conversationId}`, baseName, { persistent: true });
@@ -2324,7 +2479,7 @@ ${user.trimEnd()}
 }).get("/:name/history/channels", async (c) => {
   const name = c.req.param("name");
   const db2 = await getDb();
-  const rows = await db2.selectDistinct({ channel: agentMessages.channel }).from(agentMessages).where(eq3(agentMessages.agent, name));
+  const rows = await db2.selectDistinct({ channel: agentMessages.channel }).from(agentMessages).where(eq4(agentMessages.agent, name));
   return c.json(rows.map((r) => r.channel));
 }).get("/:name/history", async (c) => {
   const name = c.req.param("name");
@@ -2332,23 +2487,23 @@ ${user.trimEnd()}
   const limit = Math.min(Math.max(parseInt(c.req.query("limit") ?? "50", 10) || 50, 1), 200);
   const offset = Math.max(parseInt(c.req.query("offset") ?? "0", 10) || 0, 0);
   const db2 = await getDb();
-  const conditions = [eq3(agentMessages.agent, name)];
+  const conditions = [eq4(agentMessages.agent, name)];
   if (channel) {
-    conditions.push(eq3(agentMessages.channel, channel));
+    conditions.push(eq4(agentMessages.channel, channel));
   }
-  const rows = await db2.select().from(agentMessages).where(and2(...conditions)).orderBy(desc(agentMessages.created_at)).limit(limit).offset(offset);
+  const rows = await db2.select().from(agentMessages).where(and3(...conditions)).orderBy(desc2(agentMessages.created_at)).limit(limit).offset(offset);
   return c.json(rows);
 });
 var agents_default = app;
 
 // src/web/routes/auth.ts
-import { zValidator } from "@hono/zod-validator";
+import { zValidator as zValidator2 } from "@hono/zod-validator";
 import { Hono as Hono2 } from "hono";
 import { deleteCookie, getCookie as getCookie2, setCookie } from "hono/cookie";
-import { z } from "zod";
-var credentialsSchema = z.object({
-  username: z.string().min(1),
-  password: z.string().min(1)
+import { z as z2 } from "zod";
+var credentialsSchema = z2.object({
+  username: z2.string().min(1),
+  password: z2.string().min(1)
 });
 var admin = new Hono2().use(authMiddleware).get("/users", async (c) => {
   const user = c.get("user");
@@ -2373,7 +2528,7 @@ var admin = new Hono2().use(authMiddleware).get("/users", async (c) => {
   await approveUser(id);
   return c.json({ ok: true });
 });
-var app2 = new Hono2().post("/register", zValidator("json", credentialsSchema), async (c) => {
+var app2 = new Hono2().post("/register", zValidator2("json", credentialsSchema), async (c) => {
   const { username, password } = c.req.valid("json");
   const existing = await getUserByUsername(username);
   if (existing) {
@@ -2385,7 +2540,7 @@ var app2 = new Hono2().post("/register", zValidator("json", credentialsSchema),
     setCookie(c, "volute_session", sessionId, { path: "/", httpOnly: true, sameSite: "Lax" });
   }
   return c.json({ id: user.id, username: user.username, role: user.role });
-}).post("/login", zValidator("json", credentialsSchema), async (c) => {
+}).post("/login", zValidator2("json", credentialsSchema), async (c) => {
   const { username, password } = c.req.valid("json");
   const user = await verifyUser(username, password);
   if (!user) {
@@ -2534,6 +2689,8 @@ var app4 = new Hono4().get("/:name/connectors", (c) => {
   }
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
+  if (entry.stage === "seed")
+    return c.json({ error: "Seed agents cannot use connectors \u2014 sprout first" }, 403);
   const dir = agentDir(name);
   const manager = getConnectorManager();
   const envCheck = manager.checkConnectorEnv(type, name, dir);
@@ -2655,9 +2812,9 @@ var sharedEnvApp = new Hono5().get("/", (c) => {
 var env_default = app5;
 
 // src/web/routes/files.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { readdir, readFile } from "fs/promises";
-import { resolve as resolve10 } from "path";
+import { resolve as resolve9 } from "path";
 import { Hono as Hono6 } from "hono";
 var ALLOWED_FILES = /* @__PURE__ */ new Set(["SOUL.md", "MEMORY.md", "CLAUDE.md", "VOLUTE.md"]);
 var app6 = new Hono6().get("/:name/files", async (c) => {
@@ -2665,8 +2822,8 @@ var app6 = new Hono6().get("/:name/files", async (c) => {
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
-  const homeDir = resolve10(dir, "home");
-  if (!existsSync7(homeDir)) return c.json({ error: "Home directory missing" }, 404);
+  const homeDir = resolve9(dir, "home");
+  if (!existsSync6(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);
@@ -2679,8 +2836,8 @@ var app6 = new Hono6().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 = resolve10(dir, "home", filename);
-  if (!existsSync7(filePath)) {
+  const filePath = resolve9(dir, "home", filename);
+  if (!existsSync6(filePath)) {
     return c.json({ error: "File not found" }, 404);
   }
   const content = await readFile(filePath, "utf-8");
@@ -2690,16 +2847,16 @@ var files_default = app6;
 
 // src/web/routes/logs.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync8 } from "fs";
-import { resolve as resolve11 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { resolve as resolve10 } from "path";
 import { Hono as Hono7 } from "hono";
 import { streamSSE } 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 logFile = resolve11(stateDir(name), "logs", "agent.log");
-  if (!existsSync8(logFile)) {
+  const logFile = resolve10(stateDir(name), "logs", "agent.log");
+  if (!existsSync7(logFile)) {
     return c.json({ error: "No log file found" }, 404);
   }
   return streamSSE(c, async (stream) => {
@@ -2717,17 +2874,17 @@ var app7 = new Hono7().get("/:name/logs", async (c) => {
     stream.onAbort(() => {
       tail.kill();
     });
-    await new Promise((resolve17) => {
-      tail.on("exit", resolve17);
-      stream.onAbort(resolve17);
+    await new Promise((resolve16) => {
+      tail.on("exit", resolve16);
+      stream.onAbort(resolve16);
     });
   });
 }).get("/:name/logs/tail", async (c) => {
   const name = c.req.param("name");
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
-  const logFile = resolve11(stateDir(name), "logs", "agent.log");
-  if (!existsSync8(logFile)) {
+  const logFile = resolve10(stateDir(name), "logs", "agent.log");
+  if (!existsSync7(logFile)) {
     return c.json({ error: "No log file found" }, 404);
   }
   const nParam = parseInt(c.req.query("n") ?? "50", 10);
@@ -2737,8 +2894,8 @@ var app7 = new Hono7().get("/:name/logs", async (c) => {
   tail.stdout.on("data", (data) => {
     output += data.toString();
   });
-  await new Promise((resolve17) => {
-    tail.on("exit", resolve17);
+  await new Promise((resolve16) => {
+    tail.on("exit", resolve16);
   });
   return c.text(output);
 });
@@ -2762,7 +2919,10 @@ var app8 = new Hono8().get("/:name/schedules", (c) => {
   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 entry = findAgent(name);
+  if (!entry) return c.json({ error: "Agent not found" }, 404);
+  if (entry.stage === "seed")
+    return c.json({ error: "Seed agents cannot use schedules \u2014 sprout first" }, 403);
   const body = await c.req.json();
   if (!body.cron || !body.message) {
     return c.json({ error: "cron and message are required" }, 400);
@@ -2846,10 +3006,10 @@ var app9 = new Hono9().post("/restart", requireAdmin, (c) => {
       stream.writeSSE({ data: JSON.stringify(entry) }).catch(() => {
       });
     });
-    await new Promise((resolve17) => {
+    await new Promise((resolve16) => {
       stream.onAbort(() => {
         unsubscribe();
-        resolve17();
+        resolve16();
       });
     });
   });
@@ -2857,15 +3017,15 @@ var app9 = new Hono9().post("/restart", requireAdmin, (c) => {
 var system_default = app9;
 
 // src/web/routes/typing.ts
-import { zValidator as zValidator2 } from "@hono/zod-validator";
+import { zValidator as zValidator3 } from "@hono/zod-validator";
 import { Hono as Hono10 } from "hono";
-import { z as z2 } from "zod";
-var typingSchema = z2.object({
-  channel: z2.string().min(1),
-  sender: z2.string().min(1),
-  active: z2.boolean()
+import { z as z3 } from "zod";
+var typingSchema = z3.object({
+  channel: z3.string().min(1),
+  sender: z3.string().min(1),
+  active: z3.boolean()
 });
-var app10 = new Hono10().post("/:name/typing", zValidator2("json", typingSchema), (c) => {
+var app10 = new Hono10().post("/:name/typing", zValidator3("json", typingSchema), (c) => {
   const { channel, sender, active } = c.req.valid("json");
   const map = getTypingMap();
   if (active) {
@@ -2906,16 +3066,16 @@ var app11 = new Hono11().get("/update", async (c) => {
 var update_default = app11;
 
 // src/web/routes/variants.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync7, writeFileSync as writeFileSync6 } from "fs";
-import { resolve as resolve13 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync6, writeFileSync as writeFileSync5 } from "fs";
+import { resolve as resolve12 } from "path";
 import { Hono as Hono12 } from "hono";
 
 // src/lib/spawn-server.ts
 import { spawn as spawn4 } from "child_process";
-import { closeSync, mkdirSync as mkdirSync6, openSync, readFileSync as readFileSync7 } from "fs";
-import { resolve as resolve12 } from "path";
+import { closeSync, mkdirSync as mkdirSync5, openSync, readFileSync as readFileSync6 } from "fs";
+import { resolve as resolve11 } from "path";
 function tsxBin(cwd) {
-  return resolve12(cwd, "node_modules", ".bin", "tsx");
+  return resolve11(cwd, "node_modules", ".bin", "tsx");
 }
 function spawnServer(cwd, port, options) {
   if (options?.detached) {
@@ -2928,31 +3088,31 @@ function spawnAttached(cwd, port) {
     cwd,
     stdio: ["ignore", "pipe", "pipe"]
   });
-  return new Promise((resolve17) => {
-    const timeout = setTimeout(() => resolve17(null), 3e4);
+  return new Promise((resolve16) => {
+    const timeout = setTimeout(() => resolve16(null), 3e4);
     function checkOutput(data) {
       const match = data.toString().match(/listening on :(\d+)/);
       if (match) {
         clearTimeout(timeout);
-        resolve17({ child, actualPort: parseInt(match[1], 10) });
+        resolve16({ child, actualPort: parseInt(match[1], 10) });
       }
     }
     child.stdout?.on("data", checkOutput);
     child.stderr?.on("data", checkOutput);
     child.on("error", () => {
       clearTimeout(timeout);
-      resolve17(null);
+      resolve16(null);
     });
     child.on("exit", () => {
       clearTimeout(timeout);
-      resolve17(null);
+      resolve16(null);
     });
   });
 }
 function spawnDetached(cwd, port, logDir) {
-  const logsDir = logDir ?? resolve12(cwd, ".volute", "logs");
-  mkdirSync6(logsDir, { recursive: true });
-  const logPath = resolve12(logsDir, "agent.log");
+  const logsDir = logDir ?? resolve11(cwd, ".volute", "logs");
+  mkdirSync5(logsDir, { recursive: true });
+  const logPath = resolve11(logsDir, "agent.log");
   const logFd = openSync(logPath, "a");
   const child = spawn4(tsxBin(cwd), ["src/server.ts", "--port", String(port)], {
     cwd,
@@ -2972,7 +3132,7 @@ function spawnDetached(cwd, port, logDir) {
     }
     const interval = setInterval(() => {
       try {
-        const content = readFileSync7(logPath, "utf-8");
+        const content = readFileSync6(logPath, "utf-8");
         const match = content.match(/listening on :(\d+)/);
         if (match) {
           finish({ child, actualPort: parseInt(match[1], 10) });
@@ -3041,6 +3201,8 @@ var app12 = new Hono12().get("/:name/variants", async (c) => {
   const agentName = c.req.param("name");
   const entry = findAgent(agentName);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
+  if (entry.stage === "seed")
+    return c.json({ error: "Seed agents cannot create variants \u2014 sprout first" }, 403);
   let body;
   try {
     body = await c.req.json();
@@ -3052,11 +3214,11 @@ var app12 = new Hono12().get("/:name/variants", async (c) => {
   const err = validateBranchName(variantName);
   if (err) return c.json({ error: err }, 400);
   const projectRoot = agentDir(agentName);
-  const variantDir = resolve13(projectRoot, ".variants", variantName);
-  if (existsSync9(variantDir)) {
+  const variantDir = resolve12(projectRoot, ".variants", variantName);
+  if (existsSync8(variantDir)) {
     return c.json({ error: `Variant directory already exists: ${variantDir}` }, 409);
   }
-  mkdirSync7(resolve13(projectRoot, ".variants"), { recursive: true });
+  mkdirSync6(resolve12(projectRoot, ".variants"), { recursive: true });
   try {
     await gitExec(["worktree", "add", "-b", variantName, variantDir], { cwd: projectRoot });
   } catch (e) {
@@ -3070,7 +3232,7 @@ var app12 = new Hono12().get("/:name/variants", async (c) => {
     return c.json({ error: `npm install failed: ${msg}` }, 500);
   }
   if (body.soul) {
-    writeFileSync6(resolve13(variantDir, "home/SOUL.md"), body.soul);
+    writeFileSync5(resolve12(variantDir, "home/SOUL.md"), body.soul);
   }
   const variantPort = body.port ?? nextPort();
   const variant = {
@@ -3109,7 +3271,7 @@ var app12 = new Hono12().get("/:name/variants", async (c) => {
   } catch {
   }
   const projectRoot = agentDir(agentName);
-  if (existsSync9(variant.path)) {
+  if (existsSync8(variant.path)) {
     const status = (await gitExec(["status", "--porcelain"], { cwd: variant.path })).trim();
     if (status) {
       try {
@@ -3166,7 +3328,7 @@ var app12 = new Hono12().get("/:name/variants", async (c) => {
   } catch (e) {
     return c.json({ error: "Merge failed. Resolve conflicts manually." }, 500);
   }
-  if (existsSync9(variant.path)) {
+  if (existsSync8(variant.path)) {
     try {
       await gitExec(["worktree", "remove", "--force", variant.path], { cwd: projectRoot });
     } catch {
@@ -3218,7 +3380,7 @@ var app12 = new Hono12().get("/:name/variants", async (c) => {
     } catch {
     }
   }
-  if (existsSync9(variant.path)) {
+  if (existsSync8(variant.path)) {
     try {
       await gitExec(["worktree", "remove", "--force", variant.path], { cwd: projectRoot });
     } catch {
@@ -3235,221 +3397,26 @@ var app12 = new Hono12().get("/:name/variants", async (c) => {
 var variants_default = app12;
 
 // src/web/routes/volute/chat.ts
-import { readFileSync as readFileSync8 } from "fs";
-import { resolve as resolve14 } from "path";
-import { zValidator as zValidator3 } from "@hono/zod-validator";
+import { readFileSync as readFileSync7 } from "fs";
+import { resolve as resolve13 } from "path";
+import { zValidator as zValidator4 } from "@hono/zod-validator";
 import { Hono as Hono13 } from "hono";
 import { streamSSE as streamSSE3 } from "hono/streaming";
-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 as randomUUID2 } 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 = randomUUID2();
-  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)));
-    }
-  }
-  const msg = {
-    id: result.id,
-    conversation_id: conversationId,
-    role,
-    sender_name: senderName,
-    content,
-    created_at: result.created_at
-  };
-  publish(conversationId, {
-    type: "message",
-    id: msg.id,
-    role: msg.role,
-    senderName: msg.sender_name,
-    content: msg.content,
-    createdAt: msg.created_at
-  });
-  return msg;
-}
-async function getMessages(conversationId) {
-  const db2 = await getDb();
-  const rows = await db2.select().from(messages).where(eq4(messages.conversation_id, conversationId)).orderBy(messages.created_at).all();
-  return rows.map((row) => {
-    let content;
-    try {
-      const parsed = JSON.parse(row.content);
-      content = Array.isArray(parsed) ? parsed : [{ type: "text", text: row.content }];
-    } catch {
-      content = [{ type: "text", text: row.content }];
-    }
-    return { ...row, content };
-  });
-}
-async function listConversationsWithParticipants(userId) {
-  const convs = await listConversationsForUser(userId);
-  if (convs.length === 0) return [];
-  const db2 = await getDb();
-  const convIds = convs.map((c) => c.id);
-  const rows = await db2.select({
-    conversationId: conversationParticipants.conversation_id,
-    userId: users.id,
-    username: users.username,
-    userType: users.user_type,
-    role: conversationParticipants.role
-  }).from(conversationParticipants).innerJoin(users, eq4(conversationParticipants.user_id, users.id)).where(inArray(conversationParticipants.conversation_id, convIds));
-  const byConv = /* @__PURE__ */ new Map();
-  for (const r of rows) {
-    let arr = byConv.get(r.conversationId);
-    if (!arr) {
-      arr = [];
-      byConv.set(r.conversationId, arr);
-    }
-    arr.push({
-      userId: r.userId,
-      username: r.username,
-      userType: r.userType,
-      role: r.role
-    });
-  }
-  return convs.map((c) => ({ ...c, participants: byConv.get(c.id) ?? [] }));
-}
-async function findDMConversation(agentName, participantIds) {
-  const db2 = await getDb();
-  const agentConvs = await db2.select({ id: conversations.id }).from(conversations).where(eq4(conversations.agent_name, agentName)).all();
-  for (const conv of agentConvs) {
-    const rows = await db2.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(eq4(conversationParticipants.conversation_id, conv.id)).all();
-    if (rows.length !== 2) continue;
-    const ids = new Set(rows.map((r) => r.user_id));
-    if (ids.has(participantIds[0]) && ids.has(participantIds[1])) {
-      return conv.id;
-    }
-  }
-  return null;
-}
-async function deleteConversation(id) {
-  const db2 = await getDb();
-  await db2.delete(conversations).where(eq4(conversations.id, id));
-}
-
-// src/web/routes/volute/chat.ts
-var chatSchema = 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()
+import { z as z4 } from "zod";
+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() {
   try {
-    const data = JSON.parse(readFileSync8(resolve14(voluteHome(), "daemon.json"), "utf-8"));
+    const data = JSON.parse(readFileSync7(resolve13(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}`);
@@ -3465,7 +3432,7 @@ function daemonFetchInternal(path, body) {
   if (token) headers.Authorization = `Bearer ${token}`;
   return fetch(`${daemonUrl}${path}`, { method: "POST", headers, body });
 }
-var app13 = new Hono13().post("/:name/chat", zValidator3("json", chatSchema), async (c) => {
+var app13 = new Hono13().post("/:name/chat", zValidator4("json", chatSchema), async (c) => {
   const name = c.req.param("name");
   const [baseName] = name.split("@", 2);
   const entry = findAgent(baseName);
@@ -3513,7 +3480,6 @@ var app13 = new Hono13().post("/:name/chat", zValidator3("json", chatSchema), as
   }
   const conv = await getConversation(conversationId);
   const convTitle = conv?.title;
-  const channel = convTitle ? `volute:${slugify(convTitle)}` : `volute:${conversationId}`;
   const contentBlocks = [];
   if (body.message) {
     contentBlocks.push({ type: "text", text: body.message });
@@ -3527,13 +3493,21 @@ var app13 = new Hono13().post("/:name/chat", zValidator3("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-AZUDAKCP.js");
+  const { getAgentManager: getAgentManager2 } = await import("./agent-manager-HHBAAL2D.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;
+  function channelForAgent(agentUsername) {
+    return buildVoluteSlug({
+      participants,
+      agentUsername,
+      convTitle,
+      conversationId
+    });
+  }
   const channelEntry = {
     platformId: conversationId,
     platform: "volute",
@@ -3542,25 +3516,26 @@ var app13 = new Hono13().post("/:name/chat", zValidator3("json", chatSchema), as
   };
   for (const ap of agentParticipants) {
     try {
-      writeChannelEntry(ap.username, channel, channelEntry);
+      writeChannelEntry(ap.username, channelForAgent(ap.username), 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 } : {}
-  });
   for (const agentName of runningAgents) {
     const targetName = agentName === baseName ? name : agentName;
+    const channel = channelForAgent(agentName);
+    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 } : {}
+    });
     daemonFetchInternal(`/api/agents/${encodeURIComponent(targetName)}/message`, payload).then(async (res) => {
       if (!res.ok) {
         const text2 = await res.text().catch(() => "");
@@ -3588,11 +3563,11 @@ var app13 = new Hono13().post("/:name/chat", zValidator3("json", chatSchema), as
         if (!stream.aborted) console.error("[chat] SSE ping error:", err);
       });
     }, 15e3);
-    await new Promise((resolve17) => {
+    await new Promise((resolve16) => {
       stream.onAbort(() => {
         unsubscribe();
         clearInterval(keepAlive);
-        resolve17();
+        resolve16();
       });
     });
   });
@@ -3600,13 +3575,13 @@ var app13 = new Hono13().post("/:name/chat", zValidator3("json", chatSchema), as
 var chat_default = app13;
 
 // src/web/routes/volute/conversations.ts
-import { zValidator as zValidator4 } from "@hono/zod-validator";
+import { zValidator as zValidator5 } from "@hono/zod-validator";
 import { Hono as Hono14 } from "hono";
-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()
+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 app14 = new Hono14().get("/:name/conversations", async (c) => {
   const name = c.req.param("name");
@@ -3619,7 +3594,7 @@ var app14 = new Hono14().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", zValidator4("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");
@@ -3696,12 +3671,12 @@ var app14 = new Hono14().get("/:name/conversations", async (c) => {
 var conversations_default = app14;
 
 // src/web/routes/volute/user-conversations.ts
-import { zValidator as zValidator5 } from "@hono/zod-validator";
+import { zValidator as zValidator6 } from "@hono/zod-validator";
 import { Hono as Hono15 } from "hono";
-import { z as z5 } from "zod";
-var createSchema = z5.object({
-  title: z5.string().optional(),
-  participantNames: z5.array(z5.string()).min(1)
+import { z as z6 } from "zod";
+var createSchema = z6.object({
+  title: z6.string().optional(),
+  participantNames: z6.array(z6.string()).min(1)
 });
 var app15 = new Hono15().use("*", authMiddleware).get("/", async (c) => {
   const user = c.get("user");
@@ -3715,7 +3690,7 @@ var app15 = new Hono15().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();
@@ -3820,20 +3795,20 @@ async function startServer({
   hostname = "127.0.0.1"
 }) {
   let assetsDir = "";
-  let searchDir = dirname4(new URL(import.meta.url).pathname);
+  let searchDir = dirname3(new URL(import.meta.url).pathname);
   for (let i = 0; i < 5; i++) {
-    const candidate = resolve15(searchDir, "dist", "web-assets");
-    if (existsSync10(candidate)) {
+    const candidate = resolve14(searchDir, "dist", "web-assets");
+    if (existsSync9(candidate)) {
       assetsDir = candidate;
       break;
     }
-    searchDir = dirname4(searchDir);
+    searchDir = dirname3(searchDir);
   }
   if (assetsDir) {
     app_default.get("*", async (c) => {
       const urlPath = new URL(c.req.url).pathname;
       if (urlPath.startsWith("/api/")) return c.notFound();
-      const filePath = resolve15(assetsDir, urlPath.slice(1));
+      const filePath = resolve14(assetsDir, urlPath.slice(1));
       if (!filePath.startsWith(assetsDir)) return c.text("Forbidden", 403);
       const s = await stat(filePath).catch(() => null);
       if (s?.isFile()) {
@@ -3842,7 +3817,7 @@ async function startServer({
         const body = await readFile2(filePath);
         return c.body(body, 200, { "Content-Type": mime });
       }
-      const indexPath = resolve15(assetsDir, "index.html");
+      const indexPath = resolve14(assetsDir, "index.html");
       const indexStat = await stat(indexPath).catch(() => null);
       if (indexStat?.isFile()) {
         const body = await readFile2(indexPath, "utf-8");
@@ -3852,10 +3827,10 @@ async function startServer({
     });
   }
   const server = serve({ fetch: app_default.fetch, port, hostname });
-  await new Promise((resolve17, reject) => {
+  await new Promise((resolve16, reject) => {
     server.on("listening", () => {
       logger_default.info("Volute UI running", { hostname, port });
-      resolve17();
+      resolve16();
     });
     server.on("error", (err) => {
       reject(err);
@@ -3866,14 +3841,14 @@ async function startServer({
 
 // src/daemon.ts
 if (!process.env.VOLUTE_HOME) {
-  process.env.VOLUTE_HOME = resolve16(homedir2(), ".volute");
+  process.env.VOLUTE_HOME = resolve15(homedir2(), ".volute");
 }
 async function startDaemon(opts) {
   const { port, hostname } = opts;
   const myPid = String(process.pid);
   const home = voluteHome();
   if (!opts.foreground) {
-    const log2 = new RotatingLog(resolve16(home, "daemon.log"));
+    const log2 = new RotatingLog(resolve15(home, "daemon.log"));
     const write2 = (...args) => log2.write(`${format(...args)}
 `);
     console.log = write2;
@@ -3881,9 +3856,9 @@ async function startDaemon(opts) {
     console.warn = write2;
     console.info = write2;
   }
-  const DAEMON_PID_PATH = resolve16(home, "daemon.pid");
-  const DAEMON_JSON_PATH = resolve16(home, "daemon.json");
-  mkdirSync8(home, { recursive: true });
+  const DAEMON_PID_PATH = resolve15(home, "daemon.pid");
+  const DAEMON_JSON_PATH = resolve15(home, "daemon.json");
+  mkdirSync7(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);
@@ -3899,8 +3874,8 @@ async function startDaemon(opts) {
     }
     throw err;
   }
-  writeFileSync7(DAEMON_PID_PATH, myPid, { mode: 420 });
-  writeFileSync7(DAEMON_JSON_PATH, `${JSON.stringify({ port, hostname, token }, null, 2)}
+  writeFileSync6(DAEMON_PID_PATH, myPid, { mode: 420 });
+  writeFileSync6(DAEMON_JSON_PATH, `${JSON.stringify({ port, hostname, token }, null, 2)}
 `, {
     mode: 420
   });
@@ -3923,6 +3898,7 @@ async function startDaemon(opts) {
     if (!entry.running) continue;
     try {
       await manager.startAgent(entry.name);
+      if (entry.stage === "seed") continue;
       const dir = agentDir(entry.name);
       await connectors.startConnectors(entry.name, dir, entry.port, port);
       scheduler.loadSchedules(entry.name);
@@ -3954,13 +3930,13 @@ async function startDaemon(opts) {
   console.error(`[daemon] running on ${hostname}:${port}, pid ${myPid}`);
   function cleanup() {
     try {
-      if (readFileSync9(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
+      if (readFileSync8(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
         unlinkSync2(DAEMON_PID_PATH);
       }
     } catch {
     }
     try {
-      const data = JSON.parse(readFileSync9(DAEMON_JSON_PATH, "utf-8"));
+      const data = JSON.parse(readFileSync8(DAEMON_JSON_PATH, "utf-8"));
       if (data.token === token) {
         unlinkSync2(DAEMON_JSON_PATH);
       }