volute 0.9.0 → 0.10.1

package/dist/daemon.js

@@ -6,16 +6,33 @@ import {
   initAgentManager,
   loadJsonMap,
   saveJsonMap
-} from "./chunk-W6TMWYU3.js";
+} from "./chunk-KR6WRAJ4.js";
 import {
   checkForUpdate,
   checkForUpdateCached,
   getCurrentVersion
 } from "./chunk-RT6Y7AR3.js";
 import {
+  applyIsolation,
+  chownAgentDir,
+  createAgentUser,
+  deleteAgentUser,
+  ensureVoluteGroup,
+  getAgentUserIds,
+  isIsolationEnabled
+} from "./chunk-46S7YHUB.js";
+import {
+  exec,
+  resolveVoluteBin
+} from "./chunk-5C5JWR2L.js";
+import {
+  findOpenClawSession,
+  importOpenClawConnectors,
+  importPiSession,
+  parseNameFromIdentity,
   readVoluteConfig,
   writeVoluteConfig
-} from "./chunk-NETNFBA5.js";
+} from "./chunk-R3VB7NF5.js";
 import {
   agentEnvPath,
   loadMergedEnv,
@@ -27,59 +44,43 @@ import {
   CHANNELS,
   getChannelDriver
 } from "./chunk-LIPPXNIE.js";
-import {
-  agentMessages,
-  approveUser,
-  conversationParticipants,
-  conversations,
-  createUser,
-  deleteAgentUser,
-  getDb,
-  getOrCreateAgentUser,
-  getUser,
-  getUserByUsername,
-  listPendingUsers,
-  listUsers,
-  listUsersByType,
-  messages,
-  sessions,
-  users,
-  verifyUser
-} from "./chunk-ECPQXRLB.js";
+import "./chunk-D424ZQGI.js";
 import {
   slugify,
   writeChannelEntry
 } from "./chunk-N6MLQ26B.js";
 import {
-  applyIsolation
-} from "./chunk-IQXBMFZG.js";
-import {
-  resolveVoluteBin
-} from "./chunk-5C5JWR2L.js";
-import {
+  addAgent,
+  addVariant,
   agentDir,
   checkHealth,
   daemonLoopback,
+  ensureVoluteHome,
   findAgent,
   findVariant,
   getAllRunningVariants,
+  nextPort,
   readRegistry,
   readVariants,
   removeAgent,
   removeAllVariants,
+  removeVariant,
   setAgentRunning,
   setVariantRunning,
   stateDir,
+  validateAgentName,
   validateBranchName,
   voluteHome
 } from "./chunk-DP2DX4WV.js";
-import "./chunk-K3NQKI34.js";
+import {
+  __export
+} from "./chunk-K3NQKI34.js";
 
 // src/daemon.ts
 import { randomBytes } from "crypto";
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
-import { homedir } from "os";
-import { resolve as resolve10 } from "path";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync9, unlinkSync as unlinkSync2, writeFileSync as writeFileSync7 } from "fs";
+import { homedir as homedir2 } from "os";
+import { resolve as resolve16 } from "path";
 import { format } from "util";
 
 // src/lib/connector-manager.ts
@@ -319,19 +320,19 @@ var ConnectorManager = class {
     const stopKey = `${agentName}:${type}`;
     this.stopping.add(stopKey);
     agentMap.delete(type);
-    await new Promise((resolve11) => {
-      tracked.child.on("exit", () => resolve11());
+    await new Promise((resolve17) => {
+      tracked.child.on("exit", () => resolve17());
       try {
         tracked.child.kill("SIGTERM");
       } catch {
-        resolve11();
+        resolve17();
       }
       setTimeout(() => {
         try {
           tracked.child.kill("SIGKILL");
         } catch {
         }
-        resolve11();
+        resolve17();
       }, 5e3);
     });
     this.stopping.delete(stopKey);
@@ -739,9 +740,248 @@ function getTokenBudget() {
 
 // src/web/middleware/auth.ts
 import { timingSafeEqual } from "crypto";
-import { eq, lt } from "drizzle-orm";
+import { eq as eq2, lt } from "drizzle-orm";
 import { getCookie } from "hono/cookie";
 import { createMiddleware } from "hono/factory";
+
+// src/lib/auth.ts
+import { compareSync, hashSync } from "bcryptjs";
+import { and, count, eq } from "drizzle-orm";
+
+// src/lib/db.ts
+import { chmodSync, existsSync as existsSync4 } from "fs";
+import { dirname as dirname2, resolve as resolve5 } from "path";
+import { fileURLToPath } from "url";
+import { drizzle } from "drizzle-orm/libsql";
+import { migrate } from "drizzle-orm/libsql/migrator";
+
+// src/lib/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  agentMessages: () => agentMessages,
+  conversationParticipants: () => conversationParticipants,
+  conversations: () => conversations,
+  messages: () => messages,
+  sessions: () => sessions,
+  users: () => users
+});
+import { sql } from "drizzle-orm";
+import { index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+var users = sqliteTable("users", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  username: text("username").unique().notNull(),
+  password_hash: text("password_hash").notNull(),
+  role: text("role").notNull().default("pending"),
+  user_type: text("user_type").notNull().default("human"),
+  created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
+});
+var conversations = sqliteTable(
+  "conversations",
+  {
+    id: text("id").primaryKey(),
+    agent_name: text("agent_name").notNull(),
+    channel: text("channel").notNull(),
+    user_id: integer("user_id").references(() => users.id),
+    title: text("title"),
+    created_at: text("created_at").notNull().default(sql`(datetime('now'))`),
+    updated_at: text("updated_at").notNull().default(sql`(datetime('now'))`)
+  },
+  (table) => [
+    index("idx_conversations_agent_name").on(table.agent_name),
+    index("idx_conversations_user_id").on(table.user_id),
+    index("idx_conversations_updated_at").on(table.updated_at)
+  ]
+);
+var agentMessages = sqliteTable(
+  "agent_messages",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    agent: text("agent").notNull(),
+    channel: text("channel").notNull(),
+    sender: text("sender"),
+    content: text("content").notNull(),
+    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
+  },
+  (table) => [
+    index("idx_agent_messages_agent").on(table.agent),
+    index("idx_agent_messages_channel").on(table.agent, table.channel)
+  ]
+);
+var conversationParticipants = sqliteTable(
+  "conversation_participants",
+  {
+    conversation_id: text("conversation_id").notNull().references(() => conversations.id, { onDelete: "cascade" }),
+    user_id: integer("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    role: text("role").notNull().default("member"),
+    joined_at: text("joined_at").notNull().default(sql`(datetime('now'))`)
+  },
+  (table) => [
+    uniqueIndex("idx_cp_unique").on(table.conversation_id, table.user_id),
+    index("idx_cp_user_id").on(table.user_id)
+  ]
+);
+var sessions = sqliteTable("sessions", {
+  id: text("id").primaryKey(),
+  userId: integer("user_id").references(() => users.id, { onDelete: "cascade" }).notNull(),
+  createdAt: integer("created_at").notNull()
+});
+var messages = sqliteTable(
+  "messages",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    conversation_id: text("conversation_id").notNull().references(() => conversations.id, { onDelete: "cascade" }),
+    role: text("role").notNull(),
+    sender_name: text("sender_name"),
+    content: text("content").notNull(),
+    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
+  },
+  (table) => [index("idx_messages_conversation_id").on(table.conversation_id)]
+);
+
+// src/lib/db.ts
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+var migrationsFolder = existsSync4(resolve5(__dirname, "../drizzle")) ? resolve5(__dirname, "../drizzle") : resolve5(__dirname, "../../drizzle");
+var db = null;
+async function getDb() {
+  if (db) return db;
+  const dbPath = process.env.VOLUTE_DB_PATH || resolve5(voluteHome(), "volute.db");
+  db = drizzle({ connection: { url: `file:${dbPath}` }, schema: schema_exports });
+  await migrate(db, { migrationsFolder });
+  try {
+    chmodSync(dbPath, 384);
+  } catch (err) {
+    console.error(
+      `[volute] WARNING: Failed to restrict database file permissions on ${dbPath}:`,
+      err
+    );
+  }
+  return db;
+}
+
+// src/lib/auth.ts
+async function createUser(username, password) {
+  const db2 = await getDb();
+  const hash = hashSync(password, 10);
+  const [{ value }] = await db2.select({ value: count() }).from(users).where(eq(users.user_type, "human"));
+  const role = value === 0 ? "admin" : "pending";
+  const [result] = await db2.insert(users).values({ username, password_hash: hash, role }).returning({
+    id: users.id,
+    username: users.username,
+    role: users.role,
+    user_type: users.user_type,
+    created_at: users.created_at
+  });
+  return result;
+}
+async function verifyUser(username, password) {
+  const db2 = await getDb();
+  const row = await db2.select().from(users).where(eq(users.username, username)).get();
+  if (!row) return null;
+  if (row.user_type === "agent") return null;
+  if (!compareSync(password, row.password_hash)) return null;
+  const { password_hash: _, ...user } = row;
+  return user;
+}
+async function getUser(id) {
+  const db2 = await getDb();
+  const row = await db2.select({
+    id: users.id,
+    username: users.username,
+    role: users.role,
+    user_type: users.user_type,
+    created_at: users.created_at
+  }).from(users).where(eq(users.id, id)).get();
+  return row ?? null;
+}
+async function getUserByUsername(username) {
+  const db2 = await getDb();
+  const row = await db2.select({
+    id: users.id,
+    username: users.username,
+    role: users.role,
+    user_type: users.user_type,
+    created_at: users.created_at
+  }).from(users).where(eq(users.username, username)).get();
+  return row ?? null;
+}
+async function listUsers() {
+  const db2 = await getDb();
+  return db2.select({
+    id: users.id,
+    username: users.username,
+    role: users.role,
+    user_type: users.user_type,
+    created_at: users.created_at
+  }).from(users).orderBy(users.created_at).all();
+}
+async function listPendingUsers() {
+  const db2 = await getDb();
+  return db2.select({
+    id: users.id,
+    username: users.username,
+    role: users.role,
+    user_type: users.user_type,
+    created_at: users.created_at
+  }).from(users).where(eq(users.role, "pending")).orderBy(users.created_at).all();
+}
+async function listUsersByType(userType) {
+  const db2 = await getDb();
+  return db2.select({
+    id: users.id,
+    username: users.username,
+    role: users.role,
+    user_type: users.user_type,
+    created_at: users.created_at
+  }).from(users).where(eq(users.user_type, userType)).orderBy(users.created_at).all();
+}
+async function getOrCreateAgentUser(agentName) {
+  const db2 = await getDb();
+  const existing = await db2.select({
+    id: users.id,
+    username: users.username,
+    role: users.role,
+    user_type: users.user_type,
+    created_at: users.created_at
+  }).from(users).where(and(eq(users.username, agentName), eq(users.user_type, "agent"))).get();
+  if (existing) return existing;
+  try {
+    const [result] = await db2.insert(users).values({
+      username: agentName,
+      password_hash: "!agent",
+      role: "agent",
+      user_type: "agent"
+    }).returning({
+      id: users.id,
+      username: users.username,
+      role: users.role,
+      user_type: users.user_type,
+      created_at: users.created_at
+    });
+    return result;
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
+      const retried = await db2.select({
+        id: users.id,
+        username: users.username,
+        role: users.role,
+        user_type: users.user_type,
+        created_at: users.created_at
+      }).from(users).where(and(eq(users.username, agentName), eq(users.user_type, "agent"))).get();
+      if (retried) return retried;
+    }
+    throw err;
+  }
+}
+async function deleteAgentUser2(agentName) {
+  const db2 = await getDb();
+  await db2.delete(users).where(and(eq(users.username, agentName), eq(users.user_type, "agent")));
+}
+async function approveUser(id) {
+  const db2 = await getDb();
+  await db2.update(users).set({ role: "user" }).where(and(eq(users.id, id), eq(users.role, "pending")));
+}
+
+// src/web/middleware/auth.ts
 function isValidDaemonToken(token) {
   const expected = process.env.VOLUTE_DAEMON_TOKEN;
   if (!expected || token.length !== expected.length) return false;
@@ -749,29 +989,29 @@ function isValidDaemonToken(token) {
 }
 var SESSION_MAX_AGE = 864e5;
 async function createSession(userId) {
-  const db = await getDb();
+  const db2 = await getDb();
   const sessionId = crypto.randomUUID();
-  await db.insert(sessions).values({ id: sessionId, userId, createdAt: Date.now() });
+  await db2.insert(sessions).values({ id: sessionId, userId, createdAt: Date.now() });
   return sessionId;
 }
 async function deleteSession(sessionId) {
-  const db = await getDb();
-  await db.delete(sessions).where(eq(sessions.id, sessionId));
+  const db2 = await getDb();
+  await db2.delete(sessions).where(eq2(sessions.id, sessionId));
 }
 async function getSessionUserId(sessionId) {
-  const db = await getDb();
-  const row = await db.select().from(sessions).where(eq(sessions.id, sessionId)).get();
+  const db2 = await getDb();
+  const row = await db2.select().from(sessions).where(eq2(sessions.id, sessionId)).get();
   if (!row) return void 0;
   if (Date.now() - row.createdAt > SESSION_MAX_AGE) {
-    await db.delete(sessions).where(eq(sessions.id, sessionId));
+    await db2.delete(sessions).where(eq2(sessions.id, sessionId));
     return void 0;
   }
   return row.userId;
 }
 async function cleanExpiredSessions() {
-  const db = await getDb();
+  const db2 = await getDb();
   const cutoff = Date.now() - SESSION_MAX_AGE;
-  await db.delete(sessions).where(lt(sessions.createdAt, cutoff));
+  await db2.delete(sessions).where(lt(sessions.createdAt, cutoff));
 }
 var requireAdmin = createMiddleware(async (c, next) => {
   const user = c.get("user");
@@ -802,9 +1042,9 @@ var authMiddleware = createMiddleware(async (c, next) => {
 });
 
 // src/web/server.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { readFile as readFile2, stat } from "fs/promises";
-import { dirname as dirname2, extname, resolve as resolve9 } from "path";
+import { dirname as dirname4, extname, resolve as resolve15 } from "path";
 import { serve } from "@hono/node-server";
 
 // src/lib/log-buffer.ts
@@ -858,13 +1098,376 @@ import { csrf } from "hono/csrf";
 import { HTTPException } from "hono/http-exception";
 
 // src/web/routes/agents.ts
-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 {
+  cpSync as cpSync2,
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync5,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync6,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync5
+} from "fs";
+import { resolve as resolve9 } from "path";
+import { and as and2, desc, eq as eq3 } from "drizzle-orm";
 import { Hono } from "hono";
 
+// src/lib/consolidate.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve6 } from "path";
+async function consolidateMemory(agentDir2) {
+  const soulPath = resolve6(agentDir2, "home/SOUL.md");
+  const memoryPath = resolve6(agentDir2, "home/MEMORY.md");
+  const memoryDir = resolve6(agentDir2, "home/memory");
+  const soul = readFileSync3(soulPath, "utf-8");
+  const logs = [];
+  try {
+    const files = readdirSync2(memoryDir).filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f)).sort();
+    for (const filename of files) {
+      const date = filename.replace(".md", "");
+      const content2 = readFileSync3(resolve6(memoryDir, filename), "utf-8").trim();
+      if (content2) {
+        logs.push(`### ${date}
+
+${content2}`);
+      }
+    }
+  } catch {
+  }
+  if (logs.length === 0) {
+    console.log("No daily logs found.");
+    return;
+  }
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    console.error("ANTHROPIC_API_KEY not set, skipping memory consolidation.");
+    return;
+  }
+  console.log("Consolidating memory from daily logs...");
+  const userMessage = [
+    "You have daily logs from a previous environment but no long-term memory file yet.",
+    "Please review the daily logs below and produce consolidated MEMORY.md content.",
+    "Keep it concise and organized by topic. Output ONLY the markdown content for MEMORY.md, nothing else.",
+    "",
+    "## Daily logs",
+    "",
+    logs.join("\n\n")
+  ].join("\n");
+  const res = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01"
+    },
+    body: JSON.stringify({
+      model: "claude-sonnet-4-20250514",
+      max_tokens: 4096,
+      system: soul,
+      messages: [{ role: "user", content: userMessage }]
+    })
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    console.error(`Anthropic API error (${res.status}): ${body}`);
+    return;
+  }
+  const data = await res.json();
+  const content = data.content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("").trim();
+  if (content) {
+    writeFileSync2(memoryPath, `${content}
+`);
+    console.log("MEMORY.md created successfully.");
+  } else {
+    console.warn("Warning: No content produced.");
+  }
+}
+
+// src/lib/convert-session.ts
+import { randomUUID } 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 idMap = /* @__PURE__ */ new Map();
+  const messages2 = [];
+  for (const line of lines) {
+    const event = JSON.parse(line);
+    if (event.type === "message" && event.message) {
+      messages2.push(event);
+    }
+  }
+  const sdkEvents = [];
+  let lastSdkUuid = null;
+  for (let i = 0; i < messages2.length; i++) {
+    const event = messages2[i];
+    const msg = event.message;
+    if (msg.role === "user") {
+      const uuid = randomUUID();
+      idMap.set(event.id, uuid);
+      const parentUuid = event.parentId ? idMap.get(event.parentId) ?? null : null;
+      const sdkEvent = {
+        uuid,
+        parentUuid,
+        sessionId,
+        timestamp: event.timestamp,
+        cwd: opts.projectDir,
+        version: "0.1.0",
+        gitBranch: "main",
+        isSidechain: false,
+        userType: "external",
+        type: "user",
+        message: {
+          role: "user",
+          content: msg.content
+        }
+      };
+      sdkEvents.push(JSON.stringify(sdkEvent));
+      lastSdkUuid = uuid;
+    } else if (msg.role === "assistant") {
+      const content = convertAssistantContent(msg.content);
+      if (content.length === 0) continue;
+      const uuid = randomUUID();
+      idMap.set(event.id, uuid);
+      const parentUuid = event.parentId ? idMap.get(event.parentId) ?? null : null;
+      const stopReason = mapStopReason(msg.stopReason);
+      const sdkEvent = {
+        uuid,
+        parentUuid,
+        sessionId,
+        timestamp: event.timestamp,
+        cwd: opts.projectDir,
+        version: "0.1.0",
+        gitBranch: "main",
+        isSidechain: false,
+        userType: "external",
+        type: "assistant",
+        requestId: `req_imported_${randomUUID()}`,
+        message: {
+          role: "assistant",
+          content,
+          type: "message",
+          id: `msg_imported_${randomUUID()}`,
+          model: mapModel(msg.model),
+          stop_reason: stopReason,
+          stop_sequence: null,
+          usage: mapUsage(msg.usage)
+        }
+      };
+      sdkEvents.push(JSON.stringify(sdkEvent));
+      lastSdkUuid = uuid;
+    } else if (msg.role === "toolResult") {
+      const toolResults = [];
+      let lastToolResultId = event.id;
+      let lastTimestamp = event.timestamp;
+      let j = i;
+      while (j < messages2.length && messages2[j].message.role === "toolResult") {
+        const tr = messages2[j];
+        const trMsg = tr.message;
+        lastToolResultId = tr.id;
+        lastTimestamp = tr.timestamp;
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: trMsg.toolCallId,
+          content: trMsg.content,
+          ...trMsg.isError ? { is_error: true } : {}
+        });
+        j++;
+      }
+      i = j - 1;
+      const uuid = randomUUID();
+      idMap.set(lastToolResultId, uuid);
+      const parentUuid = event.parentId ? idMap.get(event.parentId) ?? null : lastSdkUuid;
+      const sdkEvent = {
+        uuid,
+        parentUuid,
+        sessionId,
+        timestamp: lastTimestamp,
+        cwd: opts.projectDir,
+        version: "0.1.0",
+        gitBranch: "main",
+        isSidechain: false,
+        userType: "external",
+        type: "user",
+        sourceToolAssistantUUID: lastSdkUuid ?? void 0,
+        toolUseResult: "imported",
+        message: {
+          role: "user",
+          content: toolResults
+        }
+      };
+      sdkEvents.push(JSON.stringify(sdkEvent));
+      lastSdkUuid = uuid;
+    }
+  }
+  const projectId = opts.projectDir.replace(/\//g, "-");
+  const sdkDir = resolve7(homedir(), ".claude", "projects", projectId);
+  mkdirSync3(sdkDir, { recursive: true });
+  const sdkPath = resolve7(sdkDir, `${sessionId}.jsonl`);
+  writeFileSync3(sdkPath, `${sdkEvents.join("\n")}
+`);
+  console.log(`Converted ${sdkEvents.length} messages \u2192 ${sdkPath}`);
+  return sessionId;
+}
+var MODEL_MAP = {
+  "claude-opus-4-5": "claude-opus-4-5-20251101",
+  "claude-sonnet-4": "claude-sonnet-4-20250514"
+};
+function mapModel(model) {
+  if (!model) return "claude-opus-4-5-20251101";
+  return MODEL_MAP[model] ?? model;
+}
+function mapStopReason(stopReason) {
+  if (!stopReason) return "end_turn";
+  const map = {
+    toolUse: "tool_use",
+    endTurn: "end_turn",
+    stop: "end_turn",
+    maxTokens: "max_tokens"
+  };
+  return map[stopReason] ?? stopReason;
+}
+function mapUsage(usage) {
+  if (!usage) return { input_tokens: 0, output_tokens: 0 };
+  return {
+    input_tokens: usage.input ?? usage.input_tokens ?? 0,
+    output_tokens: usage.output ?? usage.output_tokens ?? 0,
+    cache_read_input_tokens: usage.cacheRead ?? usage.cache_read_input_tokens ?? 0,
+    cache_creation_input_tokens: usage.cacheWrite ?? usage.cache_creation_input_tokens ?? 0
+  };
+}
+function convertAssistantContent(content) {
+  const result = [];
+  for (const block of content) {
+    if (block.type === "thinking") {
+    } else if (block.type === "toolCall") {
+      result.push({
+        type: "tool_use",
+        id: block.id,
+        name: block.name,
+        input: block.arguments ?? block.input ?? {},
+        caller: { type: "direct" }
+      });
+    } else {
+      result.push(block);
+    }
+  }
+  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;
@@ -933,7 +1536,6 @@ function getTypingMap() {
 }
 
 // src/web/routes/agents.ts
-var execFileAsync = promisify(execFile);
 async function startAgentFull(name, baseName, variantName) {
   await getAgentManager().startAgent(name);
   if (variantName) return;
@@ -959,7 +1561,7 @@ function extractTextContent(content) {
 }
 function getDaemonPort() {
   try {
-    const data = JSON.parse(readFileSync3(resolve5(voluteHome(), "daemon.json"), "utf-8"));
+    const data = JSON.parse(readFileSync6(resolve9(voluteHome(), "daemon.json"), "utf-8"));
     return data.port;
   } catch (err) {
     if (err?.code !== "ENOENT") {
@@ -998,7 +1600,247 @@ async function getAgentStatus(name, port) {
   }
   return { status, channels };
 }
-var app = new Hono().get("/", async (c) => {
+var TEMPLATE_BRANCH = "volute/template";
+async function initTemplateBranch(projectRoot, composedDir, manifest, ids, 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 };
+  await exec("git", ["checkout", "--orphan", TEMPLATE_BRANCH], opts);
+  await exec("git", ["add", "--", ...templateFiles], opts);
+  await exec("git", ["commit", "-m", "template update"], opts);
+  await exec("git", ["checkout", "-b", "main"], opts);
+  await exec("git", ["add", "-A"], opts);
+  await exec("git", ["commit", "-m", "initial commit"], opts);
+}
+async function updateTemplateBranch(projectRoot, template, agentName) {
+  const tempWorktree = resolve9(projectRoot, ".variants", "_template_update");
+  let branchExists = false;
+  try {
+    await exec("git", ["rev-parse", "--verify", TEMPLATE_BRANCH], { cwd: projectRoot });
+    branchExists = true;
+  } catch {
+  }
+  try {
+    await exec("git", ["worktree", "remove", "--force", tempWorktree], { cwd: projectRoot });
+  } catch {
+  }
+  if (existsSync6(tempWorktree)) {
+    rmSync2(tempWorktree, { recursive: true, force: true });
+  }
+  const templatesRoot = findTemplatesRoot();
+  const { composedDir, manifest } = composeTemplate(templatesRoot, template);
+  try {
+    if (branchExists) {
+      await exec("git", ["worktree", "add", tempWorktree, TEMPLATE_BRANCH], {
+        cwd: projectRoot
+      });
+    } else {
+      await exec("git", ["worktree", "add", "--detach", tempWorktree], { cwd: projectRoot });
+      await exec("git", ["checkout", "--orphan", TEMPLATE_BRANCH], { cwd: tempWorktree });
+      await exec("git", ["rm", "-rf", "--cached", "."], { cwd: tempWorktree });
+      await exec("git", ["clean", "-fd"], { cwd: tempWorktree });
+    }
+    if (branchExists) {
+      await exec("git", ["rm", "-rf", "."], { cwd: tempWorktree }).catch(() => {
+      });
+    }
+    copyTemplateToDir(composedDir, tempWorktree, agentName, manifest);
+    const initDir = resolve9(tempWorktree, ".init");
+    if (existsSync6(initDir)) {
+      rmSync2(initDir, { recursive: true, force: true });
+    }
+    await exec("git", ["add", "-A"], { cwd: tempWorktree });
+    try {
+      await exec("git", ["diff", "--cached", "--quiet"], { cwd: tempWorktree });
+    } catch {
+      await exec("git", ["commit", "-m", "template update"], { cwd: tempWorktree });
+    }
+  } finally {
+    try {
+      await exec("git", ["worktree", "remove", "--force", tempWorktree], { cwd: projectRoot });
+    } catch {
+    }
+    if (existsSync6(tempWorktree)) {
+      rmSync2(tempWorktree, { recursive: true, force: true });
+    }
+    rmSync2(composedDir, { recursive: true, force: true });
+  }
+}
+async function mergeTemplateBranch(worktreeDir) {
+  try {
+    await exec(
+      "git",
+      ["merge", TEMPLATE_BRANCH, "--allow-unrelated-histories", "-m", "merge template update"],
+      { cwd: worktreeDir }
+    );
+    return false;
+  } catch (e) {
+    try {
+      const status = await exec("git", ["status", "--porcelain"], { cwd: worktreeDir });
+      const hasConflictMarkers = status.split("\n").some((line) => line.startsWith("UU") || line.startsWith("AA"));
+      if (hasConflictMarkers) return true;
+    } catch {
+    }
+    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);
+  }
+  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);
+  const templatesRoot = findTemplatesRoot();
+  const { composedDir, manifest } = composeTemplate(templatesRoot, template);
+  try {
+    copyTemplateToDir(composedDir, dest, name, manifest);
+    applyInitFiles(dest);
+    const port = nextPort();
+    addAgent(name, port);
+    ensureVoluteGroup();
+    createAgentUser(name);
+    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 });
+    let gitWarning;
+    try {
+      await exec("git", ["init"], { cwd: dest, uid: ids?.uid, gid: ids?.gid, env });
+      await initTemplateBranch(dest, composedDir, manifest, ids, env);
+    } catch {
+      rmSync2(resolve9(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,
+      message: `Created agent: ${name} (port ${port})`,
+      ...gitWarning && { warning: gitWarning }
+    });
+  } catch (err) {
+    if (existsSync6(dest)) rmSync2(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 });
+  }
+}).post("/import", requireAdmin, async (c) => {
+  let body;
+  try {
+    body = await c.req.json();
+  } catch {
+    return c.json({ error: "Invalid JSON" }, 400);
+  }
+  const wsDir = body.workspacePath;
+  if (!wsDir || !existsSync6(resolve9(wsDir, "SOUL.md")) || !existsSync6(resolve9(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 name = body.name ?? parseNameFromIdentity(identity) ?? "imported-agent";
+  const template = body.template ?? "agent-sdk";
+  const nameErr = validateAgentName(name);
+  if (nameErr) return c.json({ error: nameErr }, 400);
+  if (findAgent(name)) return c.json({ error: `Agent already exists: ${name}` }, 409);
+  const mergedSoul = `${soul.trimEnd()}
+
+---
+
+${identity.trimEnd()}
+`;
+  const mergedMemoryExtra = user ? `
+
+---
+
+${user.trimEnd()}
+` : "";
+  ensureVoluteHome();
+  const dest = agentDir(name);
+  if (existsSync6(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);
+    if (hasMemory) {
+      const existingMemory = readFileSync6(wsMemoryPath, "utf-8");
+      writeFileSync5(
+        resolve9(dest, "home/MEMORY.md"),
+        `${existingMemory.trimEnd()}${mergedMemoryExtra}`
+      );
+    } else if (user) {
+      writeFileSync5(resolve9(dest, "home/MEMORY.md"), `${user.trimEnd()}
+`);
+    }
+    const wsMemoryDir = resolve9(wsDir, "memory");
+    let dailyLogCount = 0;
+    if (existsSync6(wsMemoryDir)) {
+      const destMemoryDir = resolve9(dest, "home/memory");
+      const files = readdirSync4(wsMemoryDir).filter((f) => f.endsWith(".md"));
+      for (const file of files) {
+        cpSync2(resolve9(wsMemoryDir, file), resolve9(destMemoryDir, file));
+      }
+      dailyLogCount = files.length;
+    }
+    const port = nextPort();
+    addAgent(name, port);
+    ensureVoluteGroup();
+    createAgentUser(name);
+    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 });
+    if (!hasMemory && dailyLogCount > 0) {
+      await consolidateMemory(dest);
+    }
+    await exec("git", ["init"], { cwd: dest, uid: ids?.uid, gid: ids?.gid, env });
+    await exec("git", ["add", "-A"], { cwd: dest, uid: ids?.uid, gid: ids?.gid, env });
+    await exec("git", ["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)) {
+      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 }));
+      }
+    }
+    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 });
+    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 });
+  }
+}).get("/", async (c) => {
   const entries = readRegistry();
   const agents = await Promise.all(
     entries.map(async (entry) => {
@@ -1011,7 +1853,7 @@ var app = new Hono().get("/", async (c) => {
   const name = c.req.param("name");
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
-  if (!existsSync4(agentDir(name))) return c.json({ error: "Agent directory missing" }, 404);
+  if (!existsSync6(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();
@@ -1037,7 +1879,7 @@ var app = new Hono().get("/", async (c) => {
     if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
   } else {
     const dir = agentDir(baseName);
-    if (!existsSync4(dir)) return c.json({ error: "Agent directory missing" }, 404);
+    if (!existsSync6(dir)) return c.json({ error: "Agent directory missing" }, 404);
   }
   if (getAgentManager().isRunning(name)) {
     return c.json({ error: "Agent already running" }, 409);
@@ -1058,7 +1900,7 @@ var app = new Hono().get("/", async (c) => {
     if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
   } else {
     const dir = agentDir(baseName);
-    if (!existsSync4(dir)) return c.json({ error: "Agent directory missing" }, 404);
+    if (!existsSync6(dir)) return c.json({ error: "Agent directory missing" }, 404);
   }
   let context;
   const contentType = c.req.header("content-type");
@@ -1086,21 +1928,58 @@ var app = new Hono().get("/", async (c) => {
         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" }
-      });
+      const variant = findVariant(baseName, mergeVariantName);
+      if (variant) {
+        const projectRoot = agentDir(baseName);
+        if (existsSync6(variant.path)) {
+          const status = (await exec("git", ["status", "--porcelain"], { cwd: variant.path })).trim();
+          if (status) {
+            try {
+              await exec("git", ["add", "-A"], { cwd: variant.path });
+              await exec(
+                "git",
+                ["commit", "-m", "Auto-commit uncommitted changes before merge"],
+                { cwd: variant.path }
+              );
+            } catch (e) {
+              console.error(
+                `[daemon] failed to auto-commit variant worktree for ${baseName}:`,
+                e
+              );
+            }
+          }
+        }
+        const mainStatus = (await exec("git", ["status", "--porcelain"], { cwd: projectRoot })).trim();
+        if (mainStatus) {
+          try {
+            await exec("git", ["add", "-A"], { cwd: projectRoot });
+            await exec("git", ["commit", "-m", "Auto-commit uncommitted changes before merge"], {
+              cwd: projectRoot
+            });
+          } catch (e) {
+            console.error(`[daemon] failed to auto-commit main worktree for ${baseName}:`, e);
+          }
+        }
+        await exec("git", ["merge", variant.branch], { cwd: projectRoot });
+        if (existsSync6(variant.path)) {
+          try {
+            await exec("git", ["worktree", "remove", "--force", variant.path], {
+              cwd: projectRoot
+            });
+          } catch {
+          }
+        }
+        try {
+          await exec("git", ["branch", "-D", variant.branch], { cwd: projectRoot });
+        } catch {
+        }
+        removeVariant(baseName, mergeVariantName);
+        try {
+          await exec("npm", ["install"], { cwd: projectRoot });
+        } catch (e) {
+          console.error(`[daemon] npm install failed after merge for ${baseName}:`, e);
+        }
+      }
     }
     if (context) {
       manager.setPendingContext(name, context);
@@ -1148,15 +2027,144 @@ var app = new Hono().get("/", async (c) => {
   }
   removeAllVariants(name);
   removeAgent(name);
-  await deleteAgentUser(name);
+  await deleteAgentUser2(name);
   const state = stateDir(name);
-  if (existsSync4(state)) {
-    rmSync(state, { recursive: true, force: true });
+  if (existsSync6(state)) {
+    rmSync2(state, { recursive: true, force: true });
   }
-  if (force && existsSync4(dir)) {
-    rmSync(dir, { recursive: true, force: true });
+  if (force && existsSync6(dir)) {
+    rmSync2(dir, { recursive: true, force: true });
+    deleteAgentUser(name);
   }
   return c.json({ ok: true });
+}).post("/:name/upgrade", requireAdmin, async (c) => {
+  const agentName = c.req.param("name");
+  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);
+  let body = {};
+  try {
+    body = await c.req.json();
+  } catch {
+  }
+  const template = body.template ?? "agent-sdk";
+  const UPGRADE_VARIANT = "upgrade";
+  if (body.continue) {
+    const worktreeDir2 = resolve9(dir, ".variants", UPGRADE_VARIANT);
+    if (!existsSync6(worktreeDir2)) {
+      return c.json({ error: "No upgrade in progress" }, 400);
+    }
+    const status = await exec("git", ["status", "--porcelain"], { cwd: worktreeDir2 });
+    const hasConflicts2 = status.split("\n").some((line) => line.startsWith("UU") || line.startsWith("AA"));
+    if (hasConflicts2) {
+      return c.json({ error: "Unresolved conflicts remain" }, 409);
+    }
+    try {
+      await exec("git", ["add", "-A"], { cwd: worktreeDir2 });
+      await exec("git", ["commit", "--no-edit"], { cwd: worktreeDir2 });
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      if (!msg.includes("nothing to commit")) throw e;
+    }
+    try {
+      await exec("npm", ["install"], { cwd: worktreeDir2 });
+      const variantPort = nextPort();
+      addVariant(agentName, {
+        name: UPGRADE_VARIANT,
+        branch: UPGRADE_VARIANT,
+        path: worktreeDir2,
+        port: variantPort,
+        created: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      await getAgentManager().startAgent(`${agentName}@${UPGRADE_VARIANT}`);
+      return c.json({
+        ok: true,
+        name: agentName,
+        variant: UPGRADE_VARIANT,
+        port: variantPort
+      });
+    } catch (err) {
+      try {
+        removeVariant(agentName, UPGRADE_VARIANT);
+      } catch {
+      }
+      try {
+        await exec("git", ["worktree", "remove", "--force", worktreeDir2], { cwd: dir });
+      } catch {
+      }
+      try {
+        await exec("git", ["branch", "-D", UPGRADE_VARIANT], { cwd: dir });
+      } catch {
+      }
+      return c.json(
+        { error: err instanceof Error ? err.message : "Failed to continue upgrade" },
+        500
+      );
+    }
+  }
+  const worktreeDir = resolve9(dir, ".variants", UPGRADE_VARIANT);
+  if (existsSync6(worktreeDir)) {
+    return c.json(
+      { error: "Upgrade variant already exists. Use continue or delete it first." },
+      409
+    );
+  }
+  await exec("git", ["worktree", "prune"], { cwd: dir });
+  try {
+    await exec("git", ["branch", "-D", UPGRADE_VARIANT], { cwd: dir });
+  } catch {
+  }
+  await updateTemplateBranch(dir, template, agentName);
+  const parentDir = resolve9(dir, ".variants");
+  if (!existsSync6(parentDir)) {
+    mkdirSync5(parentDir, { recursive: true });
+  }
+  await exec("git", ["worktree", "add", "-b", UPGRADE_VARIANT, worktreeDir], { cwd: dir });
+  const hasConflicts = await mergeTemplateBranch(worktreeDir);
+  if (hasConflicts) {
+    return c.json({
+      ok: false,
+      conflicts: true,
+      worktreeDir,
+      message: "Merge conflicts detected. Resolve them, then run with continue."
+    });
+  }
+  try {
+    await exec("npm", ["install"], { cwd: worktreeDir });
+    const variantPort = nextPort();
+    addVariant(agentName, {
+      name: UPGRADE_VARIANT,
+      branch: UPGRADE_VARIANT,
+      path: worktreeDir,
+      port: variantPort,
+      created: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await getAgentManager().startAgent(`${agentName}@${UPGRADE_VARIANT}`);
+    return c.json({
+      ok: true,
+      name: agentName,
+      variant: UPGRADE_VARIANT,
+      port: variantPort
+    });
+  } catch (err) {
+    try {
+      removeVariant(agentName, UPGRADE_VARIANT);
+    } catch {
+    }
+    try {
+      await exec("git", ["worktree", "remove", "--force", worktreeDir], { cwd: dir });
+    } catch {
+    }
+    try {
+      await exec("git", ["branch", "-D", UPGRADE_VARIANT], { cwd: dir });
+    } catch {
+    }
+    return c.json(
+      { error: err instanceof Error ? err.message : "Failed to complete upgrade" },
+      500
+    );
+  }
 }).post("/:name/message", async (c) => {
   const name = c.req.param("name");
   const [baseName, variantName] = name.split("@", 2);
@@ -1179,12 +2187,12 @@ var app = new Hono().get("/", async (c) => {
     console.error(`[daemon] failed to parse message body for ${baseName}:`, err);
   }
   const channel = parsed?.channel ?? "unknown";
-  const db = await getDb();
+  const db2 = await getDb();
   if (parsed) {
     try {
       const sender2 = parsed.sender ?? null;
       const content = extractTextContent(parsed.content);
-      await db.insert(agentMessages).values({
+      await db2.insert(agentMessages).values({
         agent: baseName,
         channel,
         sender: sender2,
@@ -1237,8 +2245,8 @@ var app = new Hono().get("/", async (c) => {
       body: forwardBody
     });
     if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      console.error(`[daemon] agent ${name} responded with ${res.status}: ${text}`);
+      const text2 = await res.text().catch(() => "");
+      console.error(`[daemon] agent ${name} responded with ${res.status}: ${text2}`);
       return c.json({ error: `Agent responded with ${res.status}` }, res.status);
     }
     let result;
@@ -1277,9 +2285,9 @@ var app = new Hono().get("/", async (c) => {
   if (!body.channel || !body.content) {
     return c.json({ error: "channel and content required" }, 400);
   }
-  const db = await getDb();
+  const db2 = await getDb();
   try {
-    await db.insert(agentMessages).values({
+    await db2.insert(agentMessages).values({
       agent: baseName,
       channel: body.channel,
       sender: body.sender ?? baseName,
@@ -1292,20 +2300,20 @@ var app = new Hono().get("/", async (c) => {
   return c.json({ ok: true });
 }).get("/:name/history/channels", async (c) => {
   const name = c.req.param("name");
-  const db = await getDb();
-  const rows = await db.selectDistinct({ channel: agentMessages.channel }).from(agentMessages).where(eq2(agentMessages.agent, name));
+  const db2 = await getDb();
+  const rows = await db2.selectDistinct({ channel: agentMessages.channel }).from(agentMessages).where(eq3(agentMessages.agent, name));
   return c.json(rows.map((r) => r.channel));
 }).get("/:name/history", async (c) => {
   const name = c.req.param("name");
   const channel = c.req.query("channel");
   const limit = Math.min(Math.max(parseInt(c.req.query("limit") ?? "50", 10) || 50, 1), 200);
   const offset = Math.max(parseInt(c.req.query("offset") ?? "0", 10) || 0, 0);
-  const db = await getDb();
-  const conditions = [eq2(agentMessages.agent, name)];
+  const db2 = await getDb();
+  const conditions = [eq3(agentMessages.agent, name)];
   if (channel) {
-    conditions.push(eq2(agentMessages.channel, channel));
+    conditions.push(eq3(agentMessages.channel, channel));
   }
-  const rows = await db.select().from(agentMessages).where(and(...conditions)).orderBy(desc(agentMessages.created_at)).limit(limit).offset(offset);
+  const rows = await db2.select().from(agentMessages).where(and2(...conditions)).orderBy(desc(agentMessages.created_at)).limit(limit).offset(offset);
   return c.json(rows);
 });
 var agents_default = app;
@@ -1624,9 +2632,9 @@ var sharedEnvApp = new Hono5().get("/", (c) => {
 var env_default = app5;
 
 // src/web/routes/files.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { readdir, readFile } from "fs/promises";
-import { resolve as resolve6 } from "path";
+import { resolve as resolve10 } 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) => {
@@ -1634,8 +2642,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 = resolve6(dir, "home");
-  if (!existsSync5(homeDir)) return c.json({ error: "Home directory missing" }, 404);
+  const homeDir = resolve10(dir, "home");
+  if (!existsSync7(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);
@@ -1648,8 +2656,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 = resolve6(dir, "home", filename);
-  if (!existsSync5(filePath)) {
+  const filePath = resolve10(dir, "home", filename);
+  if (!existsSync7(filePath)) {
     return c.json({ error: "File not found" }, 404);
   }
   const content = await readFile(filePath, "utf-8");
@@ -1659,16 +2667,16 @@ var files_default = app6;
 
 // src/web/routes/logs.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync6 } from "fs";
-import { resolve as resolve7 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { resolve as resolve11 } 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 = resolve7(stateDir(name), "logs", "agent.log");
-  if (!existsSync6(logFile)) {
+  const logFile = resolve11(stateDir(name), "logs", "agent.log");
+  if (!existsSync8(logFile)) {
     return c.json({ error: "No log file found" }, 404);
   }
   return streamSSE(c, async (stream) => {
@@ -1686,17 +2694,17 @@ var app7 = new Hono7().get("/:name/logs", async (c) => {
     stream.onAbort(() => {
       tail.kill();
     });
-    await new Promise((resolve11) => {
-      tail.on("exit", resolve11);
-      stream.onAbort(resolve11);
+    await new Promise((resolve17) => {
+      tail.on("exit", resolve17);
+      stream.onAbort(resolve17);
     });
   });
 }).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 = resolve7(stateDir(name), "logs", "agent.log");
-  if (!existsSync6(logFile)) {
+  const logFile = resolve11(stateDir(name), "logs", "agent.log");
+  if (!existsSync8(logFile)) {
     return c.json({ error: "No log file found" }, 404);
   }
   const nParam = parseInt(c.req.query("n") ?? "50", 10);
@@ -1706,8 +2714,8 @@ var app7 = new Hono7().get("/:name/logs", async (c) => {
   tail.stdout.on("data", (data) => {
     output += data.toString();
   });
-  await new Promise((resolve11) => {
-    tail.on("exit", resolve11);
+  await new Promise((resolve17) => {
+    tail.on("exit", resolve17);
   });
   return c.text(output);
 });
@@ -1798,7 +2806,13 @@ var schedules_default = app8;
 // src/web/routes/system.ts
 import { Hono as Hono9 } from "hono";
 import { streamSSE as streamSSE2 } from "hono/streaming";
-var app9 = new Hono9().get("/logs", async (c) => {
+var app9 = new Hono9().post("/restart", requireAdmin, (c) => {
+  setTimeout(() => process.exit(1), 200);
+  return c.json({ ok: true });
+}).post("/stop", requireAdmin, (c) => {
+  setTimeout(() => process.exit(0), 200);
+  return c.json({ ok: true });
+}).get("/logs", async (c) => {
   const user = c.get("user");
   if (user.role !== "admin") return c.json({ error: "Forbidden" }, 403);
   return streamSSE2(c, async (stream) => {
@@ -1809,10 +2823,10 @@ var app9 = new Hono9().get("/logs", async (c) => {
       stream.writeSSE({ data: JSON.stringify(entry) }).catch(() => {
       });
     });
-    await new Promise((resolve11) => {
+    await new Promise((resolve17) => {
       stream.onAbort(() => {
         unsubscribe();
-        resolve11();
+        resolve17();
       });
     });
   });
@@ -1869,7 +2883,124 @@ 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 { 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";
+function tsxBin(cwd) {
+  return resolve12(cwd, "node_modules", ".bin", "tsx");
+}
+function spawnServer(cwd, port, options) {
+  if (options?.detached) {
+    return spawnDetached(cwd, port, options.logDir);
+  }
+  return spawnAttached(cwd, port);
+}
+function spawnAttached(cwd, port) {
+  const child = spawn4(tsxBin(cwd), ["src/server.ts", "--port", String(port)], {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  return new Promise((resolve17) => {
+    const timeout = setTimeout(() => resolve17(null), 3e4);
+    function checkOutput(data) {
+      const match = data.toString().match(/listening on :(\d+)/);
+      if (match) {
+        clearTimeout(timeout);
+        resolve17({ child, actualPort: parseInt(match[1], 10) });
+      }
+    }
+    child.stdout?.on("data", checkOutput);
+    child.stderr?.on("data", checkOutput);
+    child.on("error", () => {
+      clearTimeout(timeout);
+      resolve17(null);
+    });
+    child.on("exit", () => {
+      clearTimeout(timeout);
+      resolve17(null);
+    });
+  });
+}
+function spawnDetached(cwd, port, logDir) {
+  const logsDir = logDir ?? resolve12(cwd, ".volute", "logs");
+  mkdirSync6(logsDir, { recursive: true });
+  const logPath = resolve12(logsDir, "agent.log");
+  const logFd = openSync(logPath, "a");
+  const child = spawn4(tsxBin(cwd), ["src/server.ts", "--port", String(port)], {
+    cwd,
+    stdio: ["ignore", logFd, logFd],
+    detached: true
+  });
+  child.unref();
+  closeSync(logFd);
+  return new Promise((res) => {
+    let done = false;
+    function finish(result) {
+      if (done) return;
+      done = true;
+      clearInterval(interval);
+      clearTimeout(timeout);
+      res(result);
+    }
+    const interval = setInterval(() => {
+      try {
+        const content = readFileSync7(logPath, "utf-8");
+        const match = content.match(/listening on :(\d+)/);
+        if (match) {
+          finish({ child, actualPort: parseInt(match[1], 10) });
+        }
+      } catch {
+      }
+    }, 100);
+    const timeout = setTimeout(() => finish(null), 3e4);
+    child.on("error", () => finish(null));
+    child.on("exit", () => finish(null));
+  });
+}
+
+// src/lib/verify.ts
+async function verify(port) {
+  const health = await checkHealth(port);
+  if (!health.ok) {
+    console.error("  Health check: failed");
+    return false;
+  }
+  console.log("  Health check: OK");
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/message`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        content: [{ type: "text", text: "ping" }],
+        channel: "system"
+      }),
+      signal: AbortSignal.timeout(6e4)
+    });
+    if (!res.ok) {
+      console.error("  Test message: failed to send");
+      return false;
+    }
+    const result = await res.json();
+    if (result.ok) {
+      console.log("  Test message: OK");
+      return true;
+    } else {
+      console.error("  Test message: unexpected response");
+      return false;
+    }
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.error(`  Test message: ${msg}`);
+    return false;
+  }
+}
+
+// src/web/routes/variants.ts
 var app12 = new Hono12().get("/:name/variants", async (c) => {
   const name = c.req.param("name");
   const entry = findAgent(name);
@@ -1883,12 +3014,203 @@ var app12 = new Hono12().get("/:name/variants", async (c) => {
     })
   );
   return c.json(results);
+}).post("/:name/variants", requireAdmin, async (c) => {
+  const agentName = c.req.param("name");
+  const entry = findAgent(agentName);
+  if (!entry) return c.json({ error: "Agent not found" }, 404);
+  let body;
+  try {
+    body = await c.req.json();
+  } catch {
+    return c.json({ error: "Invalid JSON" }, 400);
+  }
+  const variantName = body.name;
+  if (!variantName) return c.json({ error: "Variant name required" }, 400);
+  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)) {
+    return c.json({ error: `Variant directory already exists: ${variantDir}` }, 409);
+  }
+  mkdirSync7(resolve13(projectRoot, ".variants"), { recursive: true });
+  try {
+    await exec("git", ["worktree", "add", "-b", variantName, variantDir], { cwd: projectRoot });
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return c.json({ error: `Failed to create worktree: ${msg}` }, 500);
+  }
+  try {
+    await exec("npm", ["install"], { cwd: variantDir });
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return c.json({ error: `npm install failed: ${msg}` }, 500);
+  }
+  if (body.soul) {
+    writeFileSync6(resolve13(variantDir, "home/SOUL.md"), body.soul);
+  }
+  const variantPort = body.port ?? nextPort();
+  const variant = {
+    name: variantName,
+    branch: variantName,
+    path: variantDir,
+    port: variantPort,
+    created: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  addVariant(agentName, variant);
+  if (!body.noStart) {
+    try {
+      await getAgentManager().startAgent(`${agentName}@${variantName}`);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      return c.json({ error: `Variant created but failed to start: ${msg}` }, 500);
+    }
+  }
+  return c.json({
+    ok: true,
+    variant: { name: variantName, branch: variantName, path: variantDir, port: variantPort }
+  });
+}).post("/:name/variants/:variant/merge", requireAdmin, async (c) => {
+  const agentName = c.req.param("name");
+  const variantName = c.req.param("variant");
+  const entry = findAgent(agentName);
+  if (!entry) return c.json({ error: "Agent not found" }, 404);
+  const variant = findVariant(agentName, variantName);
+  if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
+  const branchErr = validateBranchName(variant.branch);
+  if (branchErr) return c.json({ error: branchErr }, 400);
+  let body = {};
+  try {
+    body = await c.req.json();
+  } catch {
+  }
+  const projectRoot = agentDir(agentName);
+  if (existsSync9(variant.path)) {
+    const status = (await exec("git", ["status", "--porcelain"], { cwd: variant.path })).trim();
+    if (status) {
+      try {
+        await exec("git", ["add", "-A"], { cwd: variant.path });
+        await exec("git", ["commit", "-m", "Auto-commit uncommitted changes before merge"], {
+          cwd: variant.path
+        });
+      } catch (e) {
+        return c.json(
+          {
+            error: "Failed to auto-commit variant changes. Commit or stash manually before merging."
+          },
+          500
+        );
+      }
+    }
+  }
+  if (!body.skipVerify) {
+    const result = await spawnServer(variant.path, 0, { detached: true });
+    if (!result) {
+      return c.json(
+        { error: "Failed to start server for verification. Use skipVerify to skip." },
+        500
+      );
+    }
+    const verified = await verify(result.actualPort);
+    try {
+      process.kill(result.child.pid);
+    } catch {
+    }
+    if (!verified) {
+      return c.json(
+        { error: "Verification failed. Fix issues or use skipVerify to proceed." },
+        500
+      );
+    }
+  }
+  const mainStatus = (await exec("git", ["status", "--porcelain"], { cwd: projectRoot })).trim();
+  if (mainStatus) {
+    try {
+      await exec("git", ["add", "-A"], { cwd: projectRoot });
+      await exec("git", ["commit", "-m", "Auto-commit uncommitted changes before merge"], {
+        cwd: projectRoot
+      });
+    } catch (e) {
+      return c.json(
+        { error: "Failed to auto-commit main changes. Commit or stash manually before merging." },
+        500
+      );
+    }
+  }
+  try {
+    await exec("git", ["merge", variant.branch], { cwd: projectRoot });
+  } catch (e) {
+    return c.json({ error: "Merge failed. Resolve conflicts manually." }, 500);
+  }
+  if (existsSync9(variant.path)) {
+    try {
+      await exec("git", ["worktree", "remove", "--force", variant.path], { cwd: projectRoot });
+    } catch {
+    }
+  }
+  try {
+    await exec("git", ["branch", "-D", variant.branch], { cwd: projectRoot });
+  } catch {
+  }
+  removeVariant(agentName, variantName);
+  try {
+    await exec("npm", ["install"], { cwd: projectRoot });
+  } catch {
+  }
+  const manager = getAgentManager();
+  const context = {
+    type: "merged",
+    name: variantName,
+    ...body.summary && { summary: body.summary },
+    ...body.justification && { justification: body.justification },
+    ...body.memory && { memory: body.memory }
+  };
+  let restartWarning;
+  try {
+    if (manager.isRunning(agentName)) {
+      await manager.stopAgent(agentName);
+    }
+    manager.setPendingContext(agentName, context);
+    await manager.startAgent(agentName);
+  } catch (e) {
+    restartWarning = `Merge succeeded but agent restart failed: ${e instanceof Error ? e.message : String(e)}`;
+    console.error(`[daemon] ${restartWarning}`);
+  }
+  return c.json({ ok: true, ...restartWarning && { warning: restartWarning } });
+}).delete("/:name/variants/:variant", requireAdmin, async (c) => {
+  const agentName = c.req.param("name");
+  const variantName = c.req.param("variant");
+  const entry = findAgent(agentName);
+  if (!entry) return c.json({ error: "Agent not found" }, 404);
+  const variant = findVariant(agentName, variantName);
+  if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
+  const projectRoot = agentDir(agentName);
+  const manager = getAgentManager();
+  const compositeKey = `${agentName}@${variantName}`;
+  if (manager.isRunning(compositeKey)) {
+    try {
+      await manager.stopAgent(compositeKey);
+    } catch {
+    }
+  }
+  if (existsSync9(variant.path)) {
+    try {
+      await exec("git", ["worktree", "remove", "--force", variant.path], { cwd: projectRoot });
+    } catch {
+    }
+  }
+  try {
+    await exec("git", ["branch", "-D", variant.branch], { cwd: projectRoot });
+  } catch {
+  }
+  removeVariant(agentName, variantName);
+  return c.json({ ok: true });
 });
 var variants_default = app12;
 
 // src/web/routes/volute/chat.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { resolve as resolve8 } from "path";
+import { readFileSync as readFileSync8 } from "fs";
+import { resolve as resolve14 } from "path";
 import { zValidator as zValidator3 } from "@hono/zod-validator";
 import { Hono as Hono13 } from "hono";
 import { streamSSE as streamSSE3 } from "hono/streaming";
@@ -1923,12 +3245,12 @@ function publish(conversationId, event) {
 }
 
 // src/lib/conversations.ts
-import { randomUUID } from "crypto";
-import { and as and2, desc as desc2, eq as eq3, inArray, isNull, sql } from "drizzle-orm";
+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 db = await getDb();
-  const id = randomUUID();
-  await db.insert(conversations).values({
+  const db2 = await getDb();
+  const id = randomUUID2();
+  await db2.insert(conversations).values({
     id,
     agent_name: agentName,
     channel,
@@ -1936,7 +3258,7 @@ async function createConversation(agentName, channel, opts) {
     title: opts?.title ?? null
   });
   if (opts?.participantIds && opts.participantIds.length > 0) {
-    await db.insert(conversationParticipants).values(
+    await db2.insert(conversationParticipants).values(
       opts.participantIds.map((uid, i) => ({
         conversation_id: id,
         user_id: uid,
@@ -1955,41 +3277,41 @@ async function createConversation(agentName, channel, opts) {
   };
 }
 async function getConversation(id) {
-  const db = await getDb();
-  const row = await db.select().from(conversations).where(eq3(conversations.id, id)).get();
+  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 db = await getDb();
-  const rows = await db.select({
+  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();
+  }).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 db = await getDb();
-  const row = await db.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(
-    and2(
-      eq3(conversationParticipants.conversation_id, conversationId),
-      eq3(conversationParticipants.user_id, userId)
+  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 db = await getDb();
-  const participantRows = await db.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(eq3(conversationParticipants.user_id, userId)).all();
+  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 db.select().from(conversations).where(inArray(conversations.id, convIds)).orderBy(desc2(conversations.updated_at)).all();
+  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 db = await getDb();
-  const row = await db.select().from(conversations).where(and2(eq3(conversations.id, conversationId), eq3(conversations.user_id, userId))).get();
+  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) {
@@ -1998,15 +3320,15 @@ async function deleteConversationForUser(id, userId) {
   return true;
 }
 async function addMessage(conversationId, role, senderName, content) {
-  const db = await getDb();
+  const db2 = await getDb();
   const serialized = JSON.stringify(content);
-  const [result] = await db.insert(messages).values({ conversation_id: conversationId, role, sender_name: senderName, content: serialized }).returning({ id: messages.id, created_at: messages.created_at });
-  await db.update(conversations).set({ updated_at: sql`datetime('now')` }).where(eq3(conversations.id, conversationId));
+  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 db.update(conversations).set({ title }).where(and2(eq3(conversations.id, conversationId), isNull(conversations.title)));
+      await db2.update(conversations).set({ title }).where(and3(eq4(conversations.id, conversationId), isNull(conversations.title)));
     }
   }
   const msg = {
@@ -2028,8 +3350,8 @@ async function addMessage(conversationId, role, senderName, content) {
   return msg;
 }
 async function getMessages(conversationId) {
-  const db = await getDb();
-  const rows = await db.select().from(messages).where(eq3(messages.conversation_id, conversationId)).orderBy(messages.created_at).all();
+  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 {
@@ -2044,15 +3366,15 @@ async function getMessages(conversationId) {
 async function listConversationsWithParticipants(userId) {
   const convs = await listConversationsForUser(userId);
   if (convs.length === 0) return [];
-  const db = await getDb();
+  const db2 = await getDb();
   const convIds = convs.map((c) => c.id);
-  const rows = await db.select({
+  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));
+  }).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);
@@ -2070,10 +3392,10 @@ async function listConversationsWithParticipants(userId) {
   return convs.map((c) => ({ ...c, participants: byConv.get(c.id) ?? [] }));
 }
 async function findDMConversation(agentName, participantIds) {
-  const db = await getDb();
-  const agentConvs = await db.select({ id: conversations.id }).from(conversations).where(eq3(conversations.agent_name, agentName)).all();
+  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 db.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(eq3(conversationParticipants.conversation_id, conv.id)).all();
+    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])) {
@@ -2083,8 +3405,8 @@ async function findDMConversation(agentName, participantIds) {
   return null;
 }
 async function deleteConversation(id) {
-  const db = await getDb();
-  await db.delete(conversations).where(eq3(conversations.id, id));
+  const db2 = await getDb();
+  await db2.delete(conversations).where(eq4(conversations.id, id));
 }
 
 // src/web/routes/volute/chat.ts
@@ -2101,7 +3423,7 @@ var chatSchema = z3.object({
 });
 function getDaemonUrl() {
   try {
-    const data = JSON.parse(readFileSync4(resolve8(voluteHome(), "daemon.json"), "utf-8"));
+    const data = JSON.parse(readFileSync8(resolve14(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}`);
@@ -2179,7 +3501,7 @@ 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-CMMH5KQQ.js");
+  const { getAgentManager: getAgentManager2 } = await import("./agent-manager-4OCID725.js");
   const manager = getAgentManager2();
   const runningAgents = agentParticipants.map((ap) => {
     const agentKey = ap.username === baseName ? name : ap.username;
@@ -2215,8 +3537,8 @@ var app13 = new Hono13().post("/:name/chat", zValidator3("json", chatSchema), as
     const targetName = agentName === baseName ? name : agentName;
     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}`);
+        const text2 = await res.text().catch(() => "");
+        console.error(`[chat] agent ${agentName} responded ${res.status}: ${text2}`);
       }
     }).catch((err) => {
       console.error(`[chat] agent ${agentName} unreachable via daemon:`, err);
@@ -2240,11 +3562,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((resolve11) => {
+    await new Promise((resolve17) => {
       stream.onAbort(() => {
         unsubscribe();
         clearInterval(keepAlive);
-        resolve11();
+        resolve17();
       });
     });
   });
@@ -2472,20 +3794,20 @@ async function startServer({
   hostname = "127.0.0.1"
 }) {
   let assetsDir = "";
-  let searchDir = dirname2(new URL(import.meta.url).pathname);
+  let searchDir = dirname4(new URL(import.meta.url).pathname);
   for (let i = 0; i < 5; i++) {
-    const candidate = resolve9(searchDir, "dist", "web-assets");
-    if (existsSync7(candidate)) {
+    const candidate = resolve15(searchDir, "dist", "web-assets");
+    if (existsSync10(candidate)) {
       assetsDir = candidate;
       break;
     }
-    searchDir = dirname2(searchDir);
+    searchDir = dirname4(searchDir);
   }
   if (assetsDir) {
     app_default.get("*", async (c) => {
       const urlPath = new URL(c.req.url).pathname;
       if (urlPath.startsWith("/api/")) return c.notFound();
-      const filePath = resolve9(assetsDir, urlPath.slice(1));
+      const filePath = resolve15(assetsDir, urlPath.slice(1));
       if (!filePath.startsWith(assetsDir)) return c.text("Forbidden", 403);
       const s = await stat(filePath).catch(() => null);
       if (s?.isFile()) {
@@ -2494,7 +3816,7 @@ async function startServer({
         const body = await readFile2(filePath);
         return c.body(body, 200, { "Content-Type": mime });
       }
-      const indexPath = resolve9(assetsDir, "index.html");
+      const indexPath = resolve15(assetsDir, "index.html");
       const indexStat = await stat(indexPath).catch(() => null);
       if (indexStat?.isFile()) {
         const body = await readFile2(indexPath, "utf-8");
@@ -2504,10 +3826,10 @@ async function startServer({
     });
   }
   const server = serve({ fetch: app_default.fetch, port, hostname });
-  await new Promise((resolve11, reject) => {
+  await new Promise((resolve17, reject) => {
     server.on("listening", () => {
       logger_default.info("Volute UI running", { hostname, port });
-      resolve11();
+      resolve17();
     });
     server.on("error", (err) => {
       reject(err);
@@ -2518,14 +3840,14 @@ async function startServer({
 
 // src/daemon.ts
 if (!process.env.VOLUTE_HOME) {
-  process.env.VOLUTE_HOME = resolve10(homedir(), ".volute");
+  process.env.VOLUTE_HOME = resolve16(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(resolve10(home, "daemon.log"));
+    const log2 = new RotatingLog(resolve16(home, "daemon.log"));
     const write2 = (...args) => log2.write(`${format(...args)}
 `);
     console.log = write2;
@@ -2533,9 +3855,9 @@ async function startDaemon(opts) {
     console.warn = write2;
     console.info = write2;
   }
-  const DAEMON_PID_PATH = resolve10(home, "daemon.pid");
-  const DAEMON_JSON_PATH = resolve10(home, "daemon.json");
-  mkdirSync3(home, { recursive: true });
+  const DAEMON_PID_PATH = resolve16(home, "daemon.pid");
+  const DAEMON_JSON_PATH = resolve16(home, "daemon.json");
+  mkdirSync8(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);
@@ -2551,8 +3873,8 @@ async function startDaemon(opts) {
     }
     throw err;
   }
-  writeFileSync2(DAEMON_PID_PATH, myPid, { mode: 420 });
-  writeFileSync2(DAEMON_JSON_PATH, `${JSON.stringify({ port, hostname, token }, null, 2)}
+  writeFileSync7(DAEMON_PID_PATH, myPid, { mode: 420 });
+  writeFileSync7(DAEMON_JSON_PATH, `${JSON.stringify({ port, hostname, token }, null, 2)}
 `, {
     mode: 420
   });
@@ -2606,13 +3928,13 @@ async function startDaemon(opts) {
   console.error(`[daemon] running on ${hostname}:${port}, pid ${myPid}`);
   function cleanup() {
     try {
-      if (readFileSync5(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
+      if (readFileSync9(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
         unlinkSync2(DAEMON_PID_PATH);
       }
     } catch {
     }
     try {
-      const data = JSON.parse(readFileSync5(DAEMON_JSON_PATH, "utf-8"));
+      const data = JSON.parse(readFileSync9(DAEMON_JSON_PATH, "utf-8"));
       if (data.token === token) {
         unlinkSync2(DAEMON_JSON_PATH);
       }