volute 0.32.0 → 0.33.0

package/dist/daemon.js

@@ -1,22 +1,28 @@
 #!/usr/bin/env node
-import {
-  computeTemplateHash
-} from "./chunk-PVY5W6QN.js";
 import {
   checkForUpdate,
   checkForUpdateCached,
   getCurrentVersion
 } from "./chunk-M7UL5S3Q.js";
+import {
+  computeTemplateHash
+} from "./chunk-PVY5W6QN.js";
 import {
   PROMPT_DEFAULTS,
   PROMPT_KEYS,
   RestartTracker,
   RotatingLog,
   announceToSystem,
+  assignSession,
+  completeOrphanedTurns,
+  completeTurn,
+  createTurn,
   deliverMessage,
   ensureSystemChannel,
   generateSystemReply,
+  getActiveTurnId,
   getDeliveryManager,
+  getLastToolUseEventId,
   getMindManager,
   getMindPromptDefaults,
   getPrompt,
@@ -33,24 +39,30 @@ import {
   initTokenBudget,
   isConversationId,
   joinSystemChannel,
+  linkToolResultToTurn,
   publish as publish2,
   publishTypingForChannels,
-  readVoluteConfig,
   recordInbound,
+  recordOutbound,
   resolveMindToken,
+  setSummaryEventId,
   startMindFull,
   stopMindFull,
   subscribe as subscribe3,
+  subscribeAll,
   substitute,
   tagUntaggedInbound,
-  writeVoluteConfig
-} from "./chunk-QBQ424EM.js";
-import "./chunk-SKLSMHXO.js";
+  tagUntaggedOutbound,
+  trackToolUse
+} from "./chunk-3Z2DPESO.js";
+import {
+  extractTextContent
+} from "./chunk-SKLSMHXO.js";
 import {
   getActiveMinds,
   onMindEvent,
   stopAll
-} from "./chunk-R7E6CRVQ.js";
+} from "./chunk-LOEJ4HPQ.js";
 import {
   addMessage,
   createChannel,
@@ -78,8 +90,8 @@ import {
   publish,
   setConversationPrivate,
   subscribe as subscribe2
-} from "./chunk-S6NFERDC.js";
-import "./chunk-SX5TKJBZ.js";
+} from "./chunk-RVGLDGMI.js";
+import "./chunk-GY5HBI7A.js";
 import {
   acceptPending,
   formatFileSize,
@@ -88,6 +100,18 @@ import {
   stageFile,
   validateFilePath
 } from "./chunk-ALEF47VT.js";
+import "./chunk-7J3HEVR7.js";
+import {
+  applyInitFiles,
+  composeTemplate,
+  copyTemplateToDir,
+  findTemplatesRoot,
+  listFiles
+} from "./chunk-G53F3JA4.js";
+import {
+  readVoluteConfig,
+  writeVoluteConfig
+} from "./chunk-OYAKCAVY.js";
 import {
   findBridgeForChannel,
   findOpenClawSession,
@@ -110,23 +134,18 @@ import {
   writeEnv
 } from "./chunk-2NGTS5UU.js";
 import {
-  assignSession,
-  completeOrphanedTurns,
-  completeTurn,
-  createTurn,
+  isHomeOnlyArchive
+} from "./chunk-I5KY25PQ.js";
+import {
   deleteSystemsConfig,
-  getActiveTurnId,
   getExtensionStandardSkills,
-  getLastToolUseEventId,
   getLoadedExtensions,
   loadAllExtensions,
   notifyExtensionsDaemonStart,
   notifyExtensionsDaemonStop,
   readSystemsConfig,
-  setSummaryEventId,
-  trackToolUse,
   writeSystemsConfig
-} from "./chunk-WKF5FEFK.js";
+} from "./chunk-A2A4KLFE.js";
 import "./chunk-PB65JZK2.js";
 import {
   approveUser,
@@ -145,18 +164,11 @@ import {
   setUserRole,
   updateUserProfile,
   verifyUser
-} from "./chunk-TDRYEPH4.js";
+} from "./chunk-JYVGHWEJ.js";
 import {
   broadcast,
   subscribe
-} from "./chunk-QZANELPX.js";
-import {
-  applyInitFiles,
-  composeTemplate,
-  copyTemplateToDir,
-  findTemplatesRoot,
-  listFiles
-} from "./chunk-G53F3JA4.js";
+} from "./chunk-KVK2DLWI.js";
 import {
   SEED_SKILLS,
   STANDARD_SKILLS,
@@ -174,16 +186,14 @@ import {
   syncBuiltinSkills,
   uninstallSkill,
   updateSkill
-} from "./chunk-D5G5YOPL.js";
-import {
-  isHomeOnlyArchive
-} from "./chunk-I5KY25PQ.js";
+} from "./chunk-C7I35G4R.js";
 import {
   aiCompleteUtility,
   getAiConfig,
   getAvailableModels,
   getConfiguredProviders,
   getEnabledModels,
+  getUtilityModel,
   qualifyModelId,
   removeAiConfig,
   removeProviderConfig,
@@ -191,33 +201,36 @@ import {
   resolveTemplate,
   saveProviderConfig,
   setEnabledModels,
+  setUtilityModel,
   unqualifyModelId
-} from "./chunk-IYDIE3HG.js";
+} from "./chunk-QTUVYI7W.js";
 import {
   logBuffer,
   logger_default
 } from "./chunk-YUIHSKR6.js";
+import {
+  exec,
+  gitExec,
+  resolveVoluteBin
+} from "./chunk-KIEPMIM5.js";
 import {
   chownMindDir,
   createMindUser,
   deleteMindUser,
   ensureVoluteGroup,
-  exec,
-  gitExec,
   isIsolationEnabled,
   mindUserName,
-  resolveVoluteBin,
   wrapForIsolation
-} from "./chunk-LGB6JBHI.js";
+} from "./chunk-VH33ZWMW.js";
 import {
   isSetupComplete,
   readGlobalConfig,
   writeGlobalConfig
-} from "./chunk-TSXLLQZW.js";
-import "./chunk-D424ZQGI.js";
+} from "./chunk-N432I7QH.js";
 import {
   readSessionFile
 } from "./chunk-UKVWJRKN.js";
+import "./chunk-D424ZQGI.js";
 import {
   buildVoluteSlug,
   slugify
@@ -247,7 +260,6 @@ import {
 } from "./chunk-LRCG2JLP.js";
 import {
   activity,
-  conversationParticipants,
   conversations,
   messages,
   mindHistory,
@@ -768,6 +780,201 @@ import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
 import { z } from "zod";
 
+// src/lib/services/imagegen.ts
+import Replicate from "replicate";
+var PROVIDERS = {
+  replicate: {
+    envVar: "REPLICATE_API_TOKEN",
+    generate: replicateGenerate,
+    search: replicateSearch
+  },
+  openrouter: {
+    envVar: "OPENROUTER_API_KEY",
+    generate: openrouterGenerate,
+    search: openrouterSearch
+  }
+};
+async function replicateGenerate(model, prompt, apiKey) {
+  const replicate = new Replicate({ auth: apiKey });
+  const output = await replicate.run(model, {
+    input: { prompt }
+  });
+  const file = Array.isArray(output) ? output[0] : output;
+  if (!file) throw new Error(`Model ${model} returned no output`);
+  if (typeof file === "string") {
+    const res = await fetch(file);
+    if (!res.ok) throw new Error(`Failed to fetch image from URL: ${res.status}`);
+    return Buffer.from(await res.arrayBuffer());
+  }
+  const chunks = [];
+  for await (const chunk of file) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks);
+}
+async function replicateSearch(query, apiKey) {
+  const replicate = new Replicate({ auth: apiKey });
+  const response = await replicate.models.search(query || "text to image");
+  return response.results.slice(0, 20).map((m) => ({
+    id: `replicate:${m.owner}/${m.name}`,
+    name: m.name,
+    description: m.description?.slice(0, 200),
+    owner: m.owner
+  }));
+}
+async function openrouterGenerate(model, prompt, apiKey) {
+  const res = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      model,
+      messages: [{ role: "user", content: prompt }],
+      modalities: ["image", "text"]
+    })
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => `HTTP ${res.status}`);
+    throw new Error(`OpenRouter API error: ${body}`);
+  }
+  const data = await res.json();
+  const imageUrl = data.choices?.[0]?.message?.images?.[0]?.image_url?.url;
+  if (!imageUrl) throw new Error("OpenRouter returned no image");
+  const match = imageUrl.match(/^data:[^;]+;base64,(.+)$/);
+  if (match) {
+    return Buffer.from(match[1], "base64");
+  }
+  const imgRes = await fetch(imageUrl);
+  if (!imgRes.ok) throw new Error(`Failed to fetch image from URL: ${imgRes.status}`);
+  return Buffer.from(await imgRes.arrayBuffer());
+}
+async function openrouterSearch(query, _apiKey) {
+  const res = await fetch("https://openrouter.ai/api/v1/models?output_modalities=image");
+  if (!res.ok) throw new Error(`OpenRouter model list failed: ${res.status}`);
+  const data = await res.json();
+  const models = data.data ?? [];
+  const q = query.toLowerCase();
+  const filtered = models.filter((m) => m.id.toLowerCase().includes(q) || m.name.toLowerCase().includes(q)).slice(0, 20);
+  return filtered.map((m) => {
+    const parts = m.id.split("/");
+    return {
+      id: `openrouter:${m.id}`,
+      name: m.name,
+      description: m.description?.slice(0, 200),
+      owner: parts[0] || m.id
+    };
+  });
+}
+function parseModelId(prefixedId) {
+  const colonIdx = prefixedId.indexOf(":");
+  if (colonIdx === -1)
+    throw new Error(
+      `Model ID must be provider-prefixed (e.g. replicate:owner/model), got: ${prefixedId}`
+    );
+  const provider = prefixedId.slice(0, colonIdx);
+  const model = prefixedId.slice(colonIdx + 1);
+  if (!PROVIDERS[provider]) throw new Error(`Unknown imagegen provider: ${provider}`);
+  return { provider, model };
+}
+function getImagegenConfig() {
+  return readGlobalConfig().imagegen ?? null;
+}
+function updateImagegenConfig(fn) {
+  const config2 = readGlobalConfig();
+  const ig = config2.imagegen ?? {};
+  fn(ig);
+  config2.imagegen = ig;
+  writeGlobalConfig(config2);
+}
+function saveProviderConfig2(id, apiKey) {
+  if (!PROVIDERS[id]) throw new Error(`Unknown imagegen provider: ${id}`);
+  updateImagegenConfig((ig) => {
+    ig.providers = ig.providers ?? {};
+    ig.providers[id] = { apiKey };
+  });
+}
+function removeProviderConfig2(id) {
+  if (!PROVIDERS[id]) throw new Error(`Unknown imagegen provider: ${id}`);
+  updateImagegenConfig((ig) => {
+    if (ig.providers) {
+      delete ig.providers[id];
+      if (Object.keys(ig.providers).length === 0) delete ig.providers;
+    }
+  });
+}
+function getConfiguredProviders2() {
+  const config2 = readGlobalConfig();
+  const ig = config2.imagegen ?? null;
+  const aiProviders = config2.ai?.providers;
+  return Object.entries(PROVIDERS).map(([id, { envVar }]) => {
+    const providerConfig = ig?.providers?.[id];
+    if (providerConfig?.apiKey) return { id, configured: true, authMethod: "api_key" };
+    if (aiProviders?.[id]?.apiKey) return { id, configured: true, authMethod: "api_key" };
+    if (process.env[envVar]) return { id, configured: true, authMethod: "env_var" };
+    return { id, configured: false, authMethod: null };
+  });
+}
+function resolveApiKey2(providerId) {
+  const provider = PROVIDERS[providerId];
+  if (!provider) return void 0;
+  const config2 = readGlobalConfig();
+  const configKey = config2.imagegen?.providers?.[providerId]?.apiKey;
+  if (configKey) return configKey;
+  const aiKey = config2.ai?.providers?.[providerId]?.apiKey;
+  if (aiKey) return aiKey;
+  return process.env[provider.envVar] || void 0;
+}
+function getEnabledModels2() {
+  return getImagegenConfig()?.models ?? [];
+}
+function setEnabledModels2(ids) {
+  updateImagegenConfig((ig) => {
+    ig.models = ids;
+    if (ig.defaultModel && !ids.includes(ig.defaultModel)) {
+      delete ig.defaultModel;
+    }
+  });
+}
+function getDefaultModel() {
+  return getImagegenConfig()?.defaultModel;
+}
+function setDefaultModel(modelId) {
+  updateImagegenConfig((ig) => {
+    if (modelId) {
+      ig.defaultModel = modelId;
+    } else {
+      delete ig.defaultModel;
+    }
+  });
+}
+async function searchModels(query, provider) {
+  if (provider) {
+    const providerDef = PROVIDERS[provider];
+    if (!providerDef) throw new Error(`Unknown imagegen provider: ${provider}`);
+    const apiKey = resolveApiKey2(provider);
+    if (!apiKey) throw new Error(`No ${provider} API key configured`);
+    return providerDef.search(query || "text to image", apiKey);
+  }
+  const searches = [];
+  for (const [id, def] of Object.entries(PROVIDERS)) {
+    const apiKey = resolveApiKey2(id);
+    if (!apiKey) continue;
+    searches.push(def.search(query || "text to image", apiKey).catch(() => []));
+  }
+  if (searches.length === 0) {
+    throw new Error("No imagegen providers configured");
+  }
+  return (await Promise.all(searches)).flat();
+}
+async function generateImage(model, prompt) {
+  const { provider: providerId, model: modelId } = parseModelId(model);
+  const apiKey = resolveApiKey2(providerId);
+  if (!apiKey) throw new Error(`No ${providerId} API key configured`);
+  return PROVIDERS[providerId].generate(modelId, prompt, apiKey);
+}
+
 // src/web/middleware/auth.ts
 import { timingSafeEqual } from "crypto";
 import { eq as eq2, lt as lt2 } from "drizzle-orm";
@@ -902,6 +1109,7 @@ var requireSelf = (paramName = "name") => createMiddleware(async (c, next) => {
 
 // src/web/api/system.ts
 var DEFAULT_API_URL = "https://volute.systems";
+var igLog = logger_default.child("imagegen");
 var app = new Hono().post("/restart", requireAdmin, (c) => {
   setTimeout(() => process.exit(1), 200);
   return c.json({ ok: true });
@@ -1044,7 +1252,77 @@ var app = new Hono().post("/restart", requireAdmin, (c) => {
   } catch (err) {
     return c.json({ error: `Connection failed: ${err.message}` }, 502);
   }
-}).get("/ai/key/:provider", requireAdmin, async (c) => {
+}).get("/imagegen/providers", requireAdmin, (c) => {
+  return c.json(getConfiguredProviders2());
+}).put(
+  "/imagegen/providers/:id",
+  requireAdmin,
+  zValidator("json", z.object({ apiKey: z.string().min(1) })),
+  (c) => {
+    const id = c.req.param("id");
+    const { apiKey } = c.req.valid("json");
+    try {
+      saveProviderConfig2(id, apiKey);
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : "Failed to save" }, 400);
+    }
+    return c.json({ ok: true });
+  }
+).delete("/imagegen/providers/:id", requireAdmin, (c) => {
+  try {
+    removeProviderConfig2(c.req.param("id"));
+  } catch (err) {
+    return c.json({ error: err instanceof Error ? err.message : "Failed to remove" }, 400);
+  }
+  return c.json({ ok: true });
+}).get("/imagegen/models", requireAdmin, (c) => {
+  const models = getEnabledModels2();
+  const defaultModel = getDefaultModel();
+  return c.json({ models, defaultModel: defaultModel ?? null });
+}).put(
+  "/imagegen/models",
+  requireAdmin,
+  zValidator(
+    "json",
+    z.object({ models: z.array(z.string()), defaultModel: z.string().nullable().optional() })
+  ),
+  (c) => {
+    const { models, defaultModel } = c.req.valid("json");
+    setEnabledModels2(models);
+    if (defaultModel !== void 0) {
+      setDefaultModel(defaultModel ?? void 0);
+    }
+    return c.json({ ok: true });
+  }
+).get("/imagegen/models/search", async (c) => {
+  const q = c.req.query("q");
+  const provider = c.req.query("provider");
+  try {
+    const results = await searchModels(q || void 0, provider || void 0);
+    return c.json(results);
+  } catch (err) {
+    igLog.error("model search failed", logger_default.errorData(err));
+    return c.json({ error: err instanceof Error ? err.message : "Search failed" }, 500);
+  }
+}).post(
+  "/imagegen/generate",
+  zValidator("json", z.object({ model: z.string().min(1), prompt: z.string().min(1) })),
+  async (c) => {
+    const { model, prompt } = c.req.valid("json");
+    try {
+      const buf = await generateImage(model, prompt);
+      return new Response(buf, {
+        headers: {
+          "Content-Type": "image/png",
+          "Content-Length": String(buf.length)
+        }
+      });
+    } catch (err) {
+      igLog.error("image generation failed", logger_default.errorData(err));
+      return c.json({ error: err instanceof Error ? err.message : "Generation failed" }, 500);
+    }
+  }
+).get("/ai/key/:provider", requireAdmin, async (c) => {
   const key = getCachedApiKey(c.req.param("provider"));
   if (!key) return c.json({ error: "No key available" }, 404);
   return c.json({ key });
@@ -1092,6 +1370,30 @@ var app = new Hono().post("/restart", requireAdmin, (c) => {
     setEnabledModels(models);
     return c.json({ ok: true });
   }
+).get("/ai/defaults", requireAdmin, (c) => {
+  const config2 = readGlobalConfig();
+  return c.json({
+    spiritModel: config2.spiritModel ?? null,
+    utilityModel: getUtilityModel() ?? null
+  });
+}).put(
+  "/ai/defaults",
+  requireAdmin,
+  zValidator(
+    "json",
+    z.object({
+      spiritModel: z.string().nullable(),
+      utilityModel: z.string().nullable()
+    })
+  ),
+  (c) => {
+    const { spiritModel, utilityModel } = c.req.valid("json");
+    const config2 = readGlobalConfig();
+    config2.spiritModel = spiritModel ?? void 0;
+    writeGlobalConfig(config2);
+    setUtilityModel(utilityModel ?? void 0);
+    return c.json({ ok: true });
+  }
 ).put(
   "/ai/providers/:id",
   requireAdmin,
@@ -1255,7 +1557,7 @@ function stopApiKeyRefresh() {
 var system_default = app;
 
 // src/web/app.ts
-import { Hono as Hono31 } from "hono";
+import { Hono as Hono30 } from "hono";
 import { bodyLimit } from "hono/body-limit";
 import { csrf } from "hono/csrf";
 import { HTTPException } from "hono/http-exception";
@@ -1718,7 +2020,7 @@ var app4 = new Hono4().post("/:platform/inbound", zValidator3("json", inboundSch
   }
   const participants = await getParticipants(channel.id);
   if (!participants.some((p) => p.userId === puppet.id)) {
-    const { addParticipant } = await import("./conversations-3O5O6AS3.js");
+    const { addParticipant } = await import("./conversations-AWI5SZW2.js");
     await addParticipant(channel.id, puppet.id);
   }
   const contentBlocks = body.content;
@@ -1811,8 +2113,8 @@ async function fanOutToBridgedMinds(opts) {
   const participants = await getParticipants(opts.conversationId);
   const mindParticipants = participants.filter((p) => p.userType === "mind");
   const participantNames = participants.map((p) => p.username);
-  const { getMindManager: getMindManager2 } = await import("./mind-manager-BNCMGYXW.js");
-  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-53DZOWW7.js");
+  const { getMindManager: getMindManager2 } = await import("./mind-manager-NBJF5D26.js");
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-JTXSN7NV.js");
   const manager = getMindManager2();
   const sm = getSleepManagerIfReady2();
   const targetMinds = mindParticipants.filter((ap) => {
@@ -2345,14 +2647,15 @@ async function send4(env, channelSlug, message, images) {
   if (token) headers.Authorization = `Bearer ${token}`;
   const voluteSession = env.VOLUTE_SESSION || (env.VOLUTE_MIND_DIR ? readSessionFile(env.VOLUTE_MIND_DIR) : void 0);
   if (voluteSession) headers["X-Volute-Session"] = voluteSession;
-  const res = await fetch(`${url}/api/minds/${encodeURIComponent(mindName)}/chat`, {
+  const res = await fetch(`${url}/api/v1/chat`, {
     method: "POST",
     headers,
     body: JSON.stringify({
       message,
       conversationId,
       sender: env.VOLUTE_SENDER ?? mindName,
-      images
+      images,
+      targetMind: mindName
     })
   });
   if (!res.ok) {
@@ -2624,7 +2927,7 @@ async function notifyMind(mindName, message) {
   const entry = await findMind(mindName);
   if (!entry) return;
   try {
-    const { sendSystemMessage } = await import("./system-chat-NPYFYZVI.js");
+    const { sendSystemMessage } = await import("./system-chat-JAPOJ3KE.js");
     await sendSystemMessage(mindName, message);
   } catch (err) {
     logger_default.warn(`[file-sharing] notify mind ${mindName} failed`, logger_default.errorData(err));
@@ -2644,13 +2947,13 @@ var app8 = new Hono9().post("/:name/files/send", requireSelf(), async (c) => {
   if (pathErr) return c.json({ error: pathErr }, 400);
   const senderDir = mindDir(senderName);
   const filePath = resolve6(senderDir, "home", body.filePath);
-  const MAX_FILE_SIZE2 = 50 * 1024 * 1024;
+  const MAX_FILE_SIZE3 = 50 * 1024 * 1024;
   const stat4 = statSync(filePath, { throwIfNoEntry: false });
   if (!stat4) return c.json({ error: `File not found: ${body.filePath}` }, 404);
-  if (stat4.size > MAX_FILE_SIZE2) {
+  if (stat4.size > MAX_FILE_SIZE3) {
     return c.json(
       {
-        error: `File too large (${formatFileSize(stat4.size)}, max ${formatFileSize(MAX_FILE_SIZE2)})`
+        error: `File too large (${formatFileSize(stat4.size)}, max ${formatFileSize(MAX_FILE_SIZE3)})`
       },
       413
     );
@@ -2727,11 +3030,11 @@ var app8 = new Hono9().post("/:name/files/send", requireSelf(), async (c) => {
   const pathErr = validateFilePath(body.filename);
   if (pathErr) return c.json({ error: pathErr }, 400);
   const content = Buffer.from(body.data, "base64");
-  const MAX_FILE_SIZE2 = 50 * 1024 * 1024;
-  if (content.length > MAX_FILE_SIZE2) {
+  const MAX_FILE_SIZE3 = 50 * 1024 * 1024;
+  if (content.length > MAX_FILE_SIZE3) {
     return c.json(
       {
-        error: `File too large (${formatFileSize(content.length)}, max ${formatFileSize(MAX_FILE_SIZE2)})`
+        error: `File too large (${formatFileSize(content.length)}, max ${formatFileSize(MAX_FILE_SIZE3)})`
       },
       413
     );
@@ -2796,92 +3099,301 @@ var app9 = new Hono10().get("/:name/avatar", async (c) => {
 });
 var files_default = app9;
 
-// src/web/api/keys.ts
+// src/web/api/history.ts
+import { and as and3, desc as desc2, eq as eq4, inArray, sql } from "drizzle-orm";
 import { Hono as Hono11 } from "hono";
-
-// src/lib/identity.ts
-import { createHash, generateKeyPairSync, sign, verify } from "crypto";
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
-import { resolve as resolve8 } from "path";
-function generateIdentity(mindDir2) {
-  const identityDir = resolve8(mindDir2, ".mind/identity");
-  mkdirSync4(identityDir, { recursive: true });
-  const { publicKey, privateKey } = generateKeyPairSync("ed25519", {
-    publicKeyEncoding: { type: "spki", format: "pem" },
-    privateKeyEncoding: { type: "pkcs8", format: "pem" }
-  });
-  const privatePath = resolve8(identityDir, "private.pem");
-  const publicPath = resolve8(identityDir, "public.pem");
-  writeFileSync4(privatePath, privateKey, { mode: 384 });
-  writeFileSync4(publicPath, publicKey, { mode: 420 });
-  const config2 = readVoluteConfig(mindDir2) ?? {};
-  config2.identity = {
-    privateKey: ".mind/identity/private.pem",
-    publicKey: ".mind/identity/public.pem"
-  };
-  writeVoluteConfig(mindDir2, config2);
-  return { publicKeyPem: publicKey, privateKeyPem: privateKey };
-}
-function getPublicKey(mindDir2) {
-  const config2 = readVoluteConfig(mindDir2);
-  const relPath = config2?.identity?.publicKey;
-  if (!relPath) return null;
-  const fullPath = resolve8(mindDir2, relPath);
-  if (!existsSync6(fullPath)) return null;
-  return readFileSync7(fullPath, "utf-8");
-}
-function getFingerprint(publicKeyPem) {
-  return createHash("sha256").update(publicKeyPem).digest("hex");
-}
-async function publishPublicKey(mindName, publicKeyPem) {
-  const systems = readSystemsConfig();
-  if (!systems) return false;
-  try {
-    const res = await fetch(`${systems.apiUrl}/api/keys/${encodeURIComponent(mindName)}`, {
-      method: "PUT",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${systems.apiKey}`
-      },
-      body: JSON.stringify({ publicKey: publicKeyPem })
-    });
-    if (!res.ok) {
-      logger_default.warn(`failed to publish key for ${mindName}: ${res.status}`);
-      return false;
-    }
-    return true;
-  } catch (err) {
-    logger_default.warn(`failed to publish key for ${mindName}`, logger_default.errorData(err));
-    return false;
+var history = new Hono11().get("/turns", async (c) => {
+  const mindFilter = c.req.query("mind");
+  const turnIdFilter = c.req.query("turnId");
+  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 = [];
+  if (mindFilter) conditions.push(eq4(turns.mind, mindFilter));
+  if (turnIdFilter) conditions.push(eq4(turns.id, turnIdFilter));
+  const turnRows = await db.select().from(turns).where(conditions.length > 0 ? and3(...conditions) : void 0).orderBy(desc2(turns.created_at)).limit(limit).offset(offset);
+  if (turnRows.length === 0) return c.json([]);
+  const turnIds = turnRows.map((t) => t.id);
+  const summaryRows = await db.select().from(mindHistory).where(and3(eq4(mindHistory.type, "summary"), inArray(mindHistory.turn_id, turnIds)));
+  const summaryByTurn = /* @__PURE__ */ new Map();
+  for (const s of summaryRows) {
+    if (s.turn_id)
+      summaryByTurn.set(s.turn_id, { content: s.content ?? "", metadata: s.metadata });
   }
-}
-
-// src/web/api/keys.ts
-var app10 = new Hono11().get("/:fingerprint", async (c) => {
-  const fingerprint = c.req.param("fingerprint");
-  for (const entry of await readRegistry()) {
-    try {
-      const pubKey = getPublicKey(mindDir(entry.name));
-      if (!pubKey) continue;
-      if (getFingerprint(pubKey) === fingerprint) {
-        return c.json({ publicKey: pubKey, mind: entry.name });
-      }
-    } catch {
+  const historyMsgRows = await db.select({
+    id: mindHistory.id,
+    mind: mindHistory.mind,
+    type: mindHistory.type,
+    channel: mindHistory.channel,
+    sender: mindHistory.sender,
+    content: mindHistory.content,
+    turn_id: mindHistory.turn_id,
+    created_at: mindHistory.created_at
+  }).from(mindHistory).where(
+    and3(
+      inArray(mindHistory.turn_id, turnIds),
+      sql`${mindHistory.type} IN ('inbound', 'outbound')`
+    )
+  ).orderBy(mindHistory.created_at);
+  const msgsByTurnChannel = /* @__PURE__ */ new Map();
+  function addToTurnChannel(turnId, channel, event) {
+    let byChannel = msgsByTurnChannel.get(turnId);
+    if (!byChannel) {
+      byChannel = /* @__PURE__ */ new Map();
+      msgsByTurnChannel.set(turnId, byChannel);
+    }
+    let arr = byChannel.get(channel);
+    if (!arr) {
+      arr = [];
+      byChannel.set(channel, arr);
     }
+    arr.push(event);
   }
-  return c.json({ error: "Key not found" }, 404);
-});
-var keys_default = app10;
-
-// src/web/api/logs.ts
-import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync7 } from "fs";
-import { resolve as resolve9 } from "path";
-import { Hono as Hono12 } from "hono";
-import { streamSSE as streamSSE3 } from "hono/streaming";
-var app11 = new Hono12().get("/:name/logs", async (c) => {
-  const name = c.req.param("name");
-  const entry = await findMind(name);
+  const turnMindMap = /* @__PURE__ */ new Map();
+  for (const t of turnRows) turnMindMap.set(t.id, t.mind);
+  for (const m of historyMsgRows) {
+    if (!m.turn_id || !m.channel) continue;
+    const mindName = turnMindMap.get(m.turn_id) ?? m.mind;
+    addToTurnChannel(m.turn_id, m.channel, {
+      id: m.id,
+      role: m.type === "inbound" ? "user" : "assistant",
+      sender: m.type === "inbound" ? m.sender ?? null : mindName,
+      content: m.content,
+      created_at: m.created_at
+    });
+  }
+  function getChannelLabel(channel) {
+    const isDM = channel.startsWith("@");
+    const colonIdx = channel.indexOf(":");
+    const raw = colonIdx >= 0 ? channel.substring(colonIdx + 1) : channel;
+    const label = isDM ? raw : raw.startsWith("#") ? raw : `#${raw}`;
+    return { label, type: isDM ? "dm" : "channel" };
+  }
+  const activityRows = await db.select().from(activity).where(inArray(activity.turn_id, turnIds)).orderBy(activity.created_at);
+  const activitiesByTurn = /* @__PURE__ */ new Map();
+  for (const a of activityRows) {
+    if (!a.turn_id) continue;
+    let arr = activitiesByTurn.get(a.turn_id);
+    if (!arr) {
+      arr = [];
+      activitiesByTurn.set(a.turn_id, arr);
+    }
+    arr.push(a);
+  }
+  const triggerIds = turnRows.filter((t) => t.trigger_event_id != null).map((t) => t.trigger_event_id);
+  const triggerMap = /* @__PURE__ */ new Map();
+  if (triggerIds.length > 0) {
+    const triggerRows = await db.select({
+      id: mindHistory.id,
+      channel: mindHistory.channel,
+      sender: mindHistory.sender,
+      content: mindHistory.content
+    }).from(mindHistory).where(inArray(mindHistory.id, triggerIds));
+    for (const r of triggerRows) triggerMap.set(r.id, r);
+  }
+  const result = turnRows.map((t) => {
+    const summary = summaryByTurn.get(t.id);
+    const turnChannels = msgsByTurnChannel.get(t.id) ?? /* @__PURE__ */ new Map();
+    const convEntries = [...turnChannels.entries()].map(([channel, evts]) => {
+      const { label, type } = getChannelLabel(channel);
+      return {
+        id: channel,
+        label,
+        type,
+        messages: evts.map((m) => ({
+          id: m.id,
+          role: m.role,
+          sender_name: m.sender,
+          content: [{ type: "text", text: m.content ?? "" }],
+          source_event_id: m.id,
+          created_at: m.created_at
+        }))
+      };
+    });
+    const turnActivities = (activitiesByTurn.get(t.id) ?? []).map((a) => {
+      let metadata = null;
+      if (a.metadata) {
+        try {
+          metadata = JSON.parse(a.metadata);
+        } catch (err) {
+          logger_default.debug(`malformed activity metadata for activity ${a.id}`, logger_default.errorData(err));
+        }
+      }
+      return {
+        id: a.id,
+        type: a.type,
+        summary: a.summary,
+        metadata,
+        source_event_id: a.source_event_id,
+        created_at: a.created_at
+      };
+    });
+    let summaryMeta = null;
+    if (summary?.metadata) {
+      try {
+        summaryMeta = JSON.parse(summary.metadata);
+      } catch (err) {
+        logger_default.debug(`malformed summary metadata for turn ${t.id}`, logger_default.errorData(err));
+      }
+    }
+    const trigger = t.trigger_event_id ? triggerMap.get(t.trigger_event_id) : null;
+    return {
+      id: t.id,
+      mind: t.mind,
+      summary: summary?.content ?? null,
+      summary_meta: summaryMeta,
+      status: t.status,
+      created_at: t.created_at,
+      trigger: trigger ? { channel: trigger.channel, sender: trigger.sender, content: trigger.content } : null,
+      conversations: convEntries,
+      activities: turnActivities
+    };
+  });
+  return c.json(result);
+}).get("/events", async (c) => {
+  const mindFilter = c.req.query("mind");
+  const stream = new ReadableStream({
+    start(controller) {
+      const encoder = new TextEncoder();
+      const send5 = (data) => {
+        controller.enqueue(encoder.encode(`data: ${data}
+
+`));
+      };
+      let unsubscribe;
+      const pingInterval = setInterval(() => {
+        try {
+          controller.enqueue(encoder.encode(": ping\n\n"));
+        } catch {
+          clearInterval(pingInterval);
+          unsubscribe?.();
+        }
+      }, 15e3);
+      if (mindFilter) {
+        unsubscribe = subscribe3(mindFilter, (event) => {
+          try {
+            send5(JSON.stringify(event));
+          } catch {
+            clearInterval(pingInterval);
+            unsubscribe?.();
+          }
+        });
+      } else {
+        unsubscribe = subscribeAll((event) => {
+          try {
+            send5(JSON.stringify(event));
+          } catch {
+            clearInterval(pingInterval);
+            unsubscribe?.();
+          }
+        });
+      }
+      c.req.raw.signal.addEventListener("abort", () => {
+        clearInterval(pingInterval);
+        unsubscribe?.();
+        try {
+          controller.close();
+        } catch {
+        }
+      });
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    }
+  });
+});
+var history_default = history;
+
+// src/web/api/keys.ts
+import { Hono as Hono12 } from "hono";
+
+// src/lib/identity.ts
+import { createHash, generateKeyPairSync, sign, verify } from "crypto";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve8 } from "path";
+function generateIdentity(mindDir2) {
+  const identityDir = resolve8(mindDir2, ".mind/identity");
+  mkdirSync4(identityDir, { recursive: true });
+  const { publicKey, privateKey } = generateKeyPairSync("ed25519", {
+    publicKeyEncoding: { type: "spki", format: "pem" },
+    privateKeyEncoding: { type: "pkcs8", format: "pem" }
+  });
+  const privatePath = resolve8(identityDir, "private.pem");
+  const publicPath = resolve8(identityDir, "public.pem");
+  writeFileSync4(privatePath, privateKey, { mode: 384 });
+  writeFileSync4(publicPath, publicKey, { mode: 420 });
+  const config2 = readVoluteConfig(mindDir2) ?? {};
+  config2.identity = {
+    privateKey: ".mind/identity/private.pem",
+    publicKey: ".mind/identity/public.pem"
+  };
+  writeVoluteConfig(mindDir2, config2);
+  return { publicKeyPem: publicKey, privateKeyPem: privateKey };
+}
+function getPublicKey(mindDir2) {
+  const config2 = readVoluteConfig(mindDir2);
+  const relPath = config2?.identity?.publicKey;
+  if (!relPath) return null;
+  const fullPath = resolve8(mindDir2, relPath);
+  if (!existsSync6(fullPath)) return null;
+  return readFileSync7(fullPath, "utf-8");
+}
+function getFingerprint(publicKeyPem) {
+  return createHash("sha256").update(publicKeyPem).digest("hex");
+}
+async function publishPublicKey(mindName, publicKeyPem) {
+  const systems = readSystemsConfig();
+  if (!systems) return false;
+  try {
+    const res = await fetch(`${systems.apiUrl}/api/keys/${encodeURIComponent(mindName)}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${systems.apiKey}`
+      },
+      body: JSON.stringify({ publicKey: publicKeyPem })
+    });
+    if (!res.ok) {
+      logger_default.warn(`failed to publish key for ${mindName}: ${res.status}`);
+      return false;
+    }
+    return true;
+  } catch (err) {
+    logger_default.warn(`failed to publish key for ${mindName}`, logger_default.errorData(err));
+    return false;
+  }
+}
+
+// src/web/api/keys.ts
+var app10 = new Hono12().get("/:fingerprint", async (c) => {
+  const fingerprint = c.req.param("fingerprint");
+  for (const entry of await readRegistry()) {
+    try {
+      const pubKey = getPublicKey(mindDir(entry.name));
+      if (!pubKey) continue;
+      if (getFingerprint(pubKey) === fingerprint) {
+        return c.json({ publicKey: pubKey, mind: entry.name });
+      }
+    } catch {
+    }
+  }
+  return c.json({ error: "Key not found" }, 404);
+});
+var keys_default = app10;
+
+// src/web/api/logs.ts
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync7 } from "fs";
+import { resolve as resolve9 } from "path";
+import { Hono as Hono13 } from "hono";
+import { streamSSE as streamSSE3 } from "hono/streaming";
+var app11 = new Hono13().get("/:name/logs", async (c) => {
+  const name = c.req.param("name");
+  const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
   const logFile = resolve9(stateDir(name), "logs", "mind.log");
   if (!existsSync7(logFile)) {
@@ -2931,9 +3443,9 @@ var logs_default = app11;
 
 // src/web/api/mind-skills.ts
 import { zValidator as zValidator4 } from "@hono/zod-validator";
-import { Hono as Hono13 } from "hono";
+import { Hono as Hono14 } from "hono";
 import { z as z4 } from "zod";
-var app12 = new Hono13().get("/:name/skills", async (c) => {
+var app12 = new Hono14().get("/:name/skills", async (c) => {
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
@@ -3022,8 +3534,8 @@ import {
 } from "fs";
 import { resolve as resolve12 } from "path";
 import { zValidator as zValidator5 } from "@hono/zod-validator";
-import { and as and4, desc as desc3, eq as eq5, inArray, sql as sql2 } from "drizzle-orm";
-import { Hono as Hono14 } from "hono";
+import { and as and5, desc as desc4, eq as eq6, sql as sql3 } from "drizzle-orm";
+import { Hono as Hono15 } from "hono";
 import { z as z5 } from "zod";
 
 // src/lib/consolidate.ts
@@ -3272,7 +3784,7 @@ function convertAssistantContent(content) {
 }
 
 // src/lib/daemon/turn-summarizer.ts
-import { and as and3, desc as desc2, eq as eq4, gt, lt as lt3, sql } from "drizzle-orm";
+import { and as and4, desc as desc3, eq as eq5, gt, lt as lt3, sql as sql2 } from "drizzle-orm";
 
 // src/lib/format-tool.ts
 function summarizeTool(name, input) {
@@ -3292,22 +3804,22 @@ var sLog = logger_default.child("turn-summarizer");
 async function gatherTurnEvents(mind, session, doneId) {
   const db = await getDb();
   const conditions = [
-    eq4(mindHistory.mind, mind),
-    eq4(mindHistory.type, "done"),
+    eq5(mindHistory.mind, mind),
+    eq5(mindHistory.type, "done"),
     lt3(mindHistory.id, doneId)
   ];
   if (session) {
-    conditions.push(eq4(mindHistory.session, session));
+    conditions.push(eq5(mindHistory.session, session));
   }
-  const prevDone = await db.select({ id: mindHistory.id }).from(mindHistory).where(and3(...conditions)).orderBy(desc2(mindHistory.id)).limit(1);
+  const prevDone = await db.select({ id: mindHistory.id }).from(mindHistory).where(and4(...conditions)).orderBy(desc3(mindHistory.id)).limit(1);
   const prevDoneId = prevDone.length > 0 ? prevDone[0].id : 0;
   const turnConditions = [
-    eq4(mindHistory.mind, mind),
+    eq5(mindHistory.mind, mind),
     gt(mindHistory.id, prevDoneId),
-    sql`${mindHistory.id} <= ${doneId}`
+    sql2`${mindHistory.id} <= ${doneId}`
   ];
   if (session) {
-    turnConditions.push(eq4(mindHistory.session, session));
+    turnConditions.push(eq5(mindHistory.session, session));
   }
   const events = await db.select({
     id: mindHistory.id,
@@ -3317,7 +3829,7 @@ async function gatherTurnEvents(mind, session, doneId) {
     content: mindHistory.content,
     metadata: mindHistory.metadata,
     created_at: mindHistory.created_at
-  }).from(mindHistory).where(and3(...turnConditions)).orderBy(mindHistory.id);
+  }).from(mindHistory).where(and4(...turnConditions)).orderBy(mindHistory.id);
   return {
     events,
     fromId: events.length > 0 ? events[0].id : doneId,
@@ -3420,7 +3932,7 @@ async function gatherTurnEventsByTurnId(turnId) {
     content: mindHistory.content,
     metadata: mindHistory.metadata,
     created_at: mindHistory.created_at
-  }).from(mindHistory).where(eq4(mindHistory.turn_id, turnId)).orderBy(mindHistory.id);
+  }).from(mindHistory).where(eq5(mindHistory.turn_id, turnId)).orderBy(mindHistory.id);
   return {
     events,
     fromId: events.length > 0 ? events[0].id : 0,
@@ -3439,8 +3951,8 @@ async function summarizeTurn(mind, session, channel, doneId, turnId) {
     if (turnId) {
       try {
         const db2 = await getDb();
-        await db2.update(mindHistory).set({ turn_id: null }).where(and3(eq4(mindHistory.turn_id, turnId), eq4(mindHistory.type, "inbound")));
-        await db2.update(messages).set({ turn_id: null }).where(eq4(messages.turn_id, turnId));
+        await db2.update(mindHistory).set({ turn_id: null }).where(and4(eq5(mindHistory.turn_id, turnId), eq5(mindHistory.type, "inbound")));
+        await db2.update(messages).set({ turn_id: null }).where(eq5(messages.turn_id, turnId));
       } catch (err) {
         sLog.error(`failed to un-tag events for interrupted turn ${turnId}`, logger_default.errorData(err));
       }
@@ -3600,7 +4112,7 @@ async function getMindStatus(name, port) {
   const manager = getMindManager();
   let status = "stopped";
   try {
-    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-53DZOWW7.js");
+    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-JTXSN7NV.js");
     if (getSleepManagerIfReady2()?.isSleeping(name)) {
       status = "sleeping";
     }
@@ -4027,7 +4539,7 @@ function formatTimeAgo(date) {
   const days = Math.floor(hours / 24);
   return `${days}d ago`;
 }
-var app13 = new Hono14().post("/", requireAdminOrSystem, zValidator5("json", createMindSchema), async (c) => {
+var app13 = new Hono15().post("/", requireAdminOrSystem, zValidator5("json", createMindSchema), async (c) => {
   const body = c.req.valid("json");
   const { name } = body;
   const template = body.template ?? resolveTemplate(body.model);
@@ -4119,7 +4631,13 @@ The human who planted you described you as: "${body.description}"
       const seedSoul = body.seedSoul ? substitute(seedSoulRaw, { name, description: descLine }) : seedSoulRaw;
       writeFileSync7(resolve12(dest, "home/SOUL.md"), seedSoul);
     }
-    const skillSet = body.skills ?? (body.stage === "seed" ? SEED_SKILLS : getStandardSkillsWithExtensions());
+    let skillSet = body.skills ?? (body.stage === "seed" ? SEED_SKILLS : getStandardSkillsWithExtensions());
+    if (body.stage === "seed" && !body.skills) {
+      const { isImagegenEnabled } = await import("./setup-TISPCO22.js");
+      if (isImagegenEnabled()) {
+        skillSet = [...skillSet, "imagegen"];
+      }
+    }
     const skillWarnings = [];
     for (const skillId of skillSet) {
       try {
@@ -4129,6 +4647,33 @@ The human who planted you described you as: "${body.description}"
         skillWarnings.push(`Failed to install skill: ${skillId}`);
       }
     }
+    if (body.stage === "seed") {
+      try {
+        const spiritEntry = await findMind("volute");
+        if (spiritEntry) {
+          const { spiritDir } = await import("./spirit-VRONKFMF.js");
+          const sDir = spiritEntry.dir ?? spiritDir();
+          const spiritConfig = readVoluteConfig(sDir) ?? {};
+          const schedules = spiritConfig.schedules ?? [];
+          const nurtureId = `nurture-${name}`;
+          if (!schedules.some((s) => s.id === nurtureId)) {
+            schedules.push({
+              id: nurtureId,
+              cron: process.env.VOLUTE_NURTURE_CRON ?? "*/5 * * * *",
+              script: `volute seed check ${name}`,
+              enabled: true,
+              whileSleeping: "skip"
+            });
+            spiritConfig.schedules = schedules;
+            writeVoluteConfig(sDir, spiritConfig);
+            const { getScheduler: getScheduler2 } = await import("./scheduler-ZZ7XGQG6.js");
+            getScheduler2().loadSchedules("volute", sDir);
+          }
+        }
+      } catch (err) {
+        logger_default.warn(`failed to add nurture schedule for ${name}`, logger_default.errorData(err));
+      }
+    }
     if (body.stage !== "seed") {
       const customSoul = await getPromptIfCustom("default_soul");
       if (customSoul) {
@@ -4300,7 +4845,7 @@ ${user.trimEnd()}
     const db = await getDb();
     const lastActiveRows = await db.select({
       mind: mindHistory.mind,
-      lastActiveAt: sql2`MAX(${mindHistory.created_at})`
+      lastActiveAt: sql3`MAX(${mindHistory.created_at})`
     }).from(mindHistory).groupBy(mindHistory.mind);
     lastActiveMap = new Map(lastActiveRows.map((r) => [r.mind, r.lastActiveAt]));
   } catch {
@@ -4384,7 +4929,7 @@ ${user.trimEnd()}
   const manager = getMindManager();
   try {
     if (context?.type === "reload") {
-      const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-53DZOWW7.js");
+      const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-JTXSN7NV.js");
       const sleepState = getSleepManagerIfReady2()?.getState(name);
       if (sleepState?.sleeping) {
         logger_default.info(`skipping reload for ${name} during sleep \u2014 will apply on next wake`);
@@ -4446,7 +4991,7 @@ ${user.trimEnd()}
     if (context?.type === "sprouted" && !entry.parent) {
       try {
         const db = await getDb();
-        const activeConvs = await db.select({ id: conversations.id, channel: conversations.channel }).from(conversations).where(eq5(conversations.mind_name, baseName)).all();
+        const activeConvs = await db.select({ id: conversations.id, channel: conversations.channel }).from(conversations).where(eq6(conversations.mind_name, baseName)).all();
         for (const conv of activeConvs) {
           await recordInbound(baseName, conv.channel, "system", "[seed has sprouted]");
           await addMessage(conv.id, "assistant", "system", [
@@ -4480,7 +5025,7 @@ ${user.trimEnd()}
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-53DZOWW7.js");
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-JTXSN7NV.js");
   const sm = getSleepManagerIfReady2();
   if (!sm) return c.json({ error: "Sleep manager not initialized" }, 503);
   return c.json(sm.getState(name));
@@ -4488,7 +5033,7 @@ ${user.trimEnd()}
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-53DZOWW7.js");
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-JTXSN7NV.js");
   const sm = getSleepManagerIfReady2();
   if (!sm) return c.json({ error: "Sleep manager not initialized" }, 503);
   if (sm.isSleeping(name)) return c.json({ error: "Mind is already sleeping" }, 409);
@@ -4508,7 +5053,7 @@ ${user.trimEnd()}
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-53DZOWW7.js");
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-JTXSN7NV.js");
   const sm = getSleepManagerIfReady2();
   if (!sm) return c.json({ error: "Sleep manager not initialized" }, 503);
   const sleepState = sm.getState(name);
@@ -4523,11 +5068,98 @@ ${user.trimEnd()}
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-53DZOWW7.js");
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-JTXSN7NV.js");
   const sm = getSleepManagerIfReady2();
   if (!sm) return c.json({ error: "Sleep manager not initialized" }, 503);
   const flushed = await sm.flushQueuedMessages(name);
   return c.json({ ok: true, flushed });
+}).patch("/:name/profile", requireSelf(), async (c) => {
+  const name = c.req.param("name");
+  const entry = await findMind(name);
+  if (!entry) return c.json({ error: "Mind not found" }, 404);
+  const body = await c.req.json();
+  const dir = entry.dir ?? mindDir(name);
+  const config2 = readVoluteConfig(dir) ?? {};
+  const profile = config2.profile ?? {};
+  if (body.displayName !== void 0) profile.displayName = body.displayName;
+  if (body.description !== void 0) profile.description = body.description;
+  if (body.avatar !== void 0) profile.avatar = body.avatar;
+  config2.profile = profile;
+  writeVoluteConfig(dir, config2);
+  const { syncMindProfile } = await import("./auth-GKCDSO4T.js");
+  await syncMindProfile(name, profile);
+  broadcast({ type: "profile_updated", mind: name, summary: `${name} profile updated` });
+  return c.json({ ok: true });
+}).get("/:name/seed-check", requireSelf(), async (c) => {
+  const name = c.req.param("name");
+  const entry = await findMind(name);
+  if (!entry) return c.json({ error: "Mind not found" }, 404);
+  if (entry.stage !== "seed") return c.json({ output: "" });
+  const db = await getDb();
+  const ORIENTATION_MARKER = "You don't have a soul yet";
+  const rawCreator = Number(process.env.VOLUTE_NURTURE_CREATOR_MINUTES);
+  const creatorThreshold = Number.isNaN(rawCreator) ? 5 : rawCreator;
+  const rawSpirit = Number(process.env.VOLUTE_NURTURE_SPIRIT_MINUTES);
+  const spiritThreshold = Number.isNaN(rawSpirit) ? 15 : rawSpirit;
+  const lastCreatorMsg = await db.select({ created_at: mindHistory.created_at }).from(mindHistory).where(
+    and5(
+      eq6(mindHistory.mind, name),
+      eq6(mindHistory.type, "inbound"),
+      sql3`${mindHistory.sender} != 'volute'`,
+      sql3`${mindHistory.sender} != ${name}`,
+      sql3`${mindHistory.sender} IS NOT NULL`
+    )
+  ).orderBy(desc4(mindHistory.created_at)).limit(1);
+  const lastSpiritMsg = await db.select({ created_at: mindHistory.created_at }).from(mindHistory).where(
+    and5(
+      eq6(mindHistory.mind, name),
+      eq6(mindHistory.type, "inbound"),
+      eq6(mindHistory.sender, "volute")
+    )
+  ).orderBy(desc4(mindHistory.created_at)).limit(1);
+  const now = Date.now();
+  const creatorTime = lastCreatorMsg[0] ? new Date(lastCreatorMsg[0].created_at).getTime() : 0;
+  const spiritTime = lastSpiritMsg[0] ? new Date(lastSpiritMsg[0].created_at).getTime() : 0;
+  const minutesSinceCreator = creatorTime ? (now - creatorTime) / 6e4 : Infinity;
+  const minutesSinceSpirit = spiritTime ? (now - spiritTime) / 6e4 : Infinity;
+  if (minutesSinceCreator < creatorThreshold && minutesSinceSpirit < spiritThreshold) {
+    return c.json({ output: "" });
+  }
+  const dir = entry.dir ?? mindDir(name);
+  const soulPath = resolve12(dir, "home/SOUL.md");
+  const memoryPath = resolve12(dir, "home/MEMORY.md");
+  const soulCustom = existsSync9(soulPath) && !readFileSync10(soulPath, "utf-8").includes(ORIENTATION_MARKER);
+  const memoryWritten = existsSync9(memoryPath) && readFileSync10(memoryPath, "utf-8").trim().length > 0;
+  const config2 = readVoluteConfig(dir);
+  const displayNameSet = !!config2?.profile?.displayName;
+  const avatarSet = !!config2?.profile?.avatar;
+  const { isImagegenEnabled } = await import("./setup-TISPCO22.js");
+  const imagegenEnabled = isImagegenEnabled();
+  const done = [];
+  const remaining = [];
+  if (soulCustom) done.push("SOUL.md written");
+  else remaining.push("Write SOUL.md");
+  if (memoryWritten) done.push("MEMORY.md written");
+  else remaining.push("Write MEMORY.md");
+  if (displayNameSet) done.push("Display name set");
+  else remaining.push("Set display name");
+  if (imagegenEnabled) {
+    if (avatarSet) done.push("Avatar set");
+    else remaining.push("Generate and set avatar");
+  }
+  const creatorStatus = minutesSinceCreator === Infinity ? "No creator messages yet" : `Last creator message: ${Math.round(minutesSinceCreator)} minutes ago`;
+  const lines = [`Seed: ${name}`, creatorStatus];
+  if (done.length > 0) lines.push(`Done: ${done.join(", ")}`);
+  if (remaining.length > 0) lines.push(`Remaining: ${remaining.join(", ")}`);
+  if (remaining.length > 0) {
+    lines.push("", `DM the seed to encourage them: echo "message" | volute chat send @${name}`);
+  } else {
+    lines.push(
+      "",
+      `All checklist items complete \u2014 the seed can run \`volute seed sprout\` when ready.`
+    );
+  }
+  return c.json({ output: lines.join("\n") });
 }).post("/:name/sprout", requireSelf(), async (c) => {
   const name = c.req.param("name");
   const entry = await findMind(name);
@@ -4536,6 +5168,24 @@ ${user.trimEnd()}
     return c.json({ error: `Mind is not a seed (stage: ${entry.stage})` }, 409);
   }
   await setMindStage(name, "sprouted");
+  try {
+    const spiritEntry = await findMind("volute");
+    if (spiritEntry) {
+      const { spiritDir } = await import("./spirit-VRONKFMF.js");
+      const sDir = spiritEntry.dir ?? spiritDir();
+      const spiritConfig = readVoluteConfig(sDir);
+      if (spiritConfig?.schedules) {
+        const nurtureId = `nurture-${name}`;
+        spiritConfig.schedules = spiritConfig.schedules.filter((s) => s.id !== nurtureId);
+        if (spiritConfig.schedules.length === 0) spiritConfig.schedules = void 0;
+        writeVoluteConfig(sDir, spiritConfig);
+        const { getScheduler: getScheduler2 } = await import("./scheduler-ZZ7XGQG6.js");
+        getScheduler2().loadSchedules("volute", sDir);
+      }
+    }
+  } catch (err) {
+    logger_default.warn(`failed to clean up nurture schedule for ${name}`, logger_default.errorData(err));
+  }
   return c.json({ ok: true });
 }).delete("/:name", requireAdmin, async (c) => {
   const name = c.req.param("name");
@@ -4953,7 +5603,7 @@ ${user.trimEnd()}
   if (!body.systemPrompt || !body.message) {
     return c.json({ error: "systemPrompt and message required" }, 400);
   }
-  const { aiComplete: aiCompleteFn, isAiConfigured } = await import("./ai-service-ZIPCV3MX.js");
+  const { aiComplete: aiCompleteFn, isAiConfigured } = await import("./ai-service-SBY2WG7O.js");
   if (!isAiConfigured()) {
     return c.json({ error: "AI service not configured" }, 503);
   }
@@ -5003,6 +5653,8 @@ ${user.trimEnd()}
       }
     }
   }
+  const MARKER_RE = /\[volute:(?:outbound|activity):\d+\]/g;
+  const cleanContent = body.type === "tool_result" && body.content ? body.content.replace(MARKER_RE, "").trimEnd() : body.content;
   const db = await getDb();
   let insertedId;
   try {
@@ -5012,7 +5664,7 @@ ${user.trimEnd()}
       session: body.session ?? null,
       channel: body.channel ?? null,
       message_id: body.messageId ?? null,
-      content: body.content ?? null,
+      content: cleanContent ?? null,
       metadata: body.metadata ? JSON.stringify(body.metadata) : null,
       turn_id: turnId ?? null
     }).returning({ id: mindHistory.id });
@@ -5023,13 +5675,21 @@ ${user.trimEnd()}
   if (body.type === "tool_use" && insertedId != null) {
     trackToolUse(baseName, body.session, insertedId);
   }
+  if (body.type === "tool_result" && turnId && body.content) {
+    const toolUseEventId = getLastToolUseEventId(baseName, body.session);
+    try {
+      await linkToolResultToTurn(baseName, turnId, body.content, toolUseEventId);
+    } catch (err) {
+      logger_default.error("failed to link outbound to turn", logger_default.errorData(err));
+    }
+  }
   publish2(baseName, {
     mind: baseName,
     type: body.type,
     session: body.session,
     channel: body.channel,
     messageId: body.messageId,
-    content: body.content,
+    content: cleanContent,
     metadata: body.metadata,
     turnId: turnId ?? void 0
   });
@@ -5056,6 +5716,11 @@ ${user.trimEnd()}
       const busy = body.session ? dm.isSessionBusy(baseName, body.session) : false;
       if (!busy) {
         const completedTurnId = await completeTurn(baseName, body.session);
+        if (completedTurnId) {
+          tagUntaggedOutbound(baseName, completedTurnId).catch(
+            (err) => logger_default.warn("failed to tag orphaned outbound records", logger_default.errorData(err))
+          );
+        }
         if (insertedId != null) {
           summarizeTurn(baseName, body.session, body.channel, insertedId, completedTurnId).catch(
             (err) => logger_default.error("turn summarization failed", logger_default.errorData(err))
@@ -5067,6 +5732,11 @@ ${user.trimEnd()}
         logger_default.error("turn completion check failed", logger_default.errorData(err));
       }
       const completedTurnId = await completeTurn(baseName, body.session);
+      if (completedTurnId) {
+        tagUntaggedOutbound(baseName, completedTurnId).catch(
+          (err2) => logger_default.warn("failed to tag orphaned outbound records", logger_default.errorData(err2))
+        );
+      }
       if (insertedId != null) {
         summarizeTurn(baseName, body.session, body.channel, insertedId, completedTurnId).catch(
           (err2) => logger_default.error("turn summarization failed", logger_default.errorData(err2))
@@ -5167,228 +5837,49 @@ ${user.trimEnd()}
   const db = await getDb();
   const rows = await db.select({
     session: mindHistory.session,
-    started_at: sql2`MIN(${mindHistory.created_at})`,
-    event_count: sql2`COUNT(*)`,
-    message_count: sql2`SUM(CASE WHEN ${mindHistory.type} IN ('inbound','outbound') THEN 1 ELSE 0 END)`,
-    tool_count: sql2`SUM(CASE WHEN ${mindHistory.type}='tool_use' THEN 1 ELSE 0 END)`
-  }).from(mindHistory).where(and4(eq5(mindHistory.mind, name), sql2`${mindHistory.session} IS NOT NULL`)).groupBy(mindHistory.session).orderBy(sql2`MIN(${mindHistory.created_at}) DESC`);
+    started_at: sql3`MIN(${mindHistory.created_at})`,
+    event_count: sql3`COUNT(*)`,
+    message_count: sql3`SUM(CASE WHEN ${mindHistory.type} IN ('inbound','outbound') THEN 1 ELSE 0 END)`,
+    tool_count: sql3`SUM(CASE WHEN ${mindHistory.type}='tool_use' THEN 1 ELSE 0 END)`
+  }).from(mindHistory).where(and5(eq6(mindHistory.mind, name), sql3`${mindHistory.session} IS NOT NULL`)).groupBy(mindHistory.session).orderBy(sql3`MIN(${mindHistory.created_at}) DESC`);
   return c.json(rows);
 }).get("/:name/history/channels", async (c) => {
   const name = c.req.param("name");
   const db = await getDb();
-  const rows = await db.selectDistinct({ channel: mindHistory.channel }).from(mindHistory).where(eq5(mindHistory.mind, name));
+  const rows = await db.selectDistinct({ channel: mindHistory.channel }).from(mindHistory).where(eq6(mindHistory.mind, name));
   return c.json(rows.map((r) => r.channel));
 }).get("/:name/history/export", async (c) => {
   const name = c.req.param("name");
   if (!await findMind(name)) return c.json({ error: "Mind not found" }, 404);
   const db = await getDb();
-  const rows = await db.select().from(mindHistory).where(eq5(mindHistory.mind, name));
+  const rows = await db.select().from(mindHistory).where(eq6(mindHistory.mind, name));
   return c.json(rows);
-}).get("/:name/history/turns", async (c) => {
+}).get("/:name/history/turn", async (c) => {
   const name = c.req.param("name");
-  const turnIdFilter = c.req.query("turnId");
-  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 = [eq5(turns.mind, name)];
-  if (turnIdFilter) conditions.push(eq5(turns.id, turnIdFilter));
-  const turnRows = await db.select().from(turns).where(and4(...conditions)).orderBy(desc3(turns.created_at)).limit(limit).offset(offset);
-  if (turnRows.length === 0) return c.json([]);
-  const turnIds = turnRows.map((t) => t.id);
-  const summaryRows = await db.select().from(mindHistory).where(
-    and4(
-      eq5(mindHistory.mind, name),
-      eq5(mindHistory.type, "summary"),
-      inArray(mindHistory.turn_id, turnIds)
-    )
-  );
-  const summaryByTurn = /* @__PURE__ */ new Map();
-  for (const s of summaryRows) {
-    if (s.turn_id)
-      summaryByTurn.set(s.turn_id, { content: s.content ?? "", metadata: s.metadata });
-  }
-  const msgRows = await db.select({
-    id: messages.id,
-    conversation_id: messages.conversation_id,
-    role: messages.role,
-    sender_name: messages.sender_name,
-    content: messages.content,
-    source_event_id: messages.source_event_id,
-    turn_id: messages.turn_id,
-    created_at: messages.created_at
-  }).from(messages).where(inArray(messages.turn_id, turnIds)).orderBy(messages.created_at);
-  const msgsByTurnConv = /* @__PURE__ */ new Map();
-  const convIds = /* @__PURE__ */ new Set();
-  for (const m of msgRows) {
-    if (!m.turn_id) continue;
-    let byConv = msgsByTurnConv.get(m.turn_id);
-    if (!byConv) {
-      byConv = /* @__PURE__ */ new Map();
-      msgsByTurnConv.set(m.turn_id, byConv);
-    }
-    let arr = byConv.get(m.conversation_id);
-    if (!arr) {
-      arr = [];
-      byConv.set(m.conversation_id, arr);
-    }
-    arr.push(m);
-    convIds.add(m.conversation_id);
-  }
-  const convMeta = /* @__PURE__ */ new Map();
-  const convParticipantsMap = /* @__PURE__ */ new Map();
-  if (convIds.size > 0) {
-    const convIdsArr = [...convIds];
-    const convRows = await db.select({
-      id: conversations.id,
-      type: conversations.type,
-      name: conversations.name,
-      title: conversations.title
-    }).from(conversations).where(inArray(conversations.id, convIdsArr));
-    for (const c2 of convRows) convMeta.set(c2.id, c2);
-    const cpRows = await db.select({
-      conversationId: conversationParticipants.conversation_id,
-      username: users.username,
-      displayName: users.display_name
-    }).from(conversationParticipants).innerJoin(users, eq5(conversationParticipants.user_id, users.id)).where(inArray(conversationParticipants.conversation_id, convIdsArr));
-    for (const cp of cpRows) {
-      let arr = convParticipantsMap.get(cp.conversationId);
-      if (!arr) {
-        arr = [];
-        convParticipantsMap.set(cp.conversationId, arr);
-      }
-      arr.push({ username: cp.username, displayName: cp.displayName });
-    }
-  }
-  function getConvLabel(convId) {
-    const meta = convMeta.get(convId);
-    if (!meta) return "Conversation";
-    if (meta.type === "channel" && meta.name) return `#${meta.name}`;
-    const parts = convParticipantsMap.get(convId) ?? [];
-    if (meta.type === "dm" && parts.length === 2) {
-      const other = parts.find((p) => p.username !== name);
-      if (other) return `@${other.displayName || other.username}`;
-    }
-    if (meta.title) return meta.title;
-    return "Conversation";
-  }
-  const activityRows = await db.select().from(activity).where(inArray(activity.turn_id, turnIds)).orderBy(activity.created_at);
-  const activitiesByTurn = /* @__PURE__ */ new Map();
-  for (const a of activityRows) {
-    if (!a.turn_id) continue;
-    let arr = activitiesByTurn.get(a.turn_id);
-    if (!arr) {
-      arr = [];
-      activitiesByTurn.set(a.turn_id, arr);
-    }
-    arr.push(a);
-  }
-  const triggerIds = turnRows.filter((t) => t.trigger_event_id != null).map((t) => t.trigger_event_id);
-  const triggerMap = /* @__PURE__ */ new Map();
-  if (triggerIds.length > 0) {
-    const triggerRows = await db.select({
-      id: mindHistory.id,
-      channel: mindHistory.channel,
-      sender: mindHistory.sender,
-      content: mindHistory.content
-    }).from(mindHistory).where(inArray(mindHistory.id, triggerIds));
-    for (const r of triggerRows) triggerMap.set(r.id, r);
-  }
-  const result = turnRows.map((t) => {
-    const summary = summaryByTurn.get(t.id);
-    const turnConvs = msgsByTurnConv.get(t.id) ?? /* @__PURE__ */ new Map();
-    const convEntries = [...turnConvs.entries()].map(([convId, msgs]) => {
-      const meta = convMeta.get(convId);
-      return {
-        id: convId,
-        label: getConvLabel(convId),
-        type: meta?.type ?? "dm",
-        messages: msgs.map((m) => {
-          let content;
-          try {
-            const parsed = JSON.parse(m.content);
-            content = Array.isArray(parsed) ? parsed : [{ type: "text", text: m.content }];
-          } catch {
-            content = [{ type: "text", text: m.content }];
-          }
-          return {
-            id: m.id,
-            role: m.role,
-            sender_name: m.sender_name,
-            content,
-            source_event_id: m.source_event_id,
-            created_at: m.created_at
-          };
-        })
-      };
-    });
-    const turnActivities = (activitiesByTurn.get(t.id) ?? []).map((a) => {
-      let metadata = null;
-      if (a.metadata) {
-        try {
-          metadata = JSON.parse(a.metadata);
-        } catch (err) {
-          logger_default.debug(`malformed activity metadata for activity ${a.id}`, logger_default.errorData(err));
-        }
-      }
-      return {
-        id: a.id,
-        type: a.type,
-        summary: a.summary,
-        metadata,
-        source_event_id: a.source_event_id,
-        created_at: a.created_at
-      };
-    });
-    let summaryMeta = null;
-    if (summary?.metadata) {
-      try {
-        summaryMeta = JSON.parse(summary.metadata);
-      } catch (err) {
-        logger_default.debug(`malformed summary metadata for turn ${t.id}`, logger_default.errorData(err));
-      }
-    }
-    const trigger = t.trigger_event_id ? triggerMap.get(t.trigger_event_id) : null;
-    return {
-      id: t.id,
-      summary: summary?.content ?? null,
-      summary_meta: summaryMeta,
-      status: t.status,
-      created_at: t.created_at,
-      trigger: trigger ? { channel: trigger.channel, sender: trigger.sender, content: trigger.content } : null,
-      conversations: convEntries,
-      activities: turnActivities
-    };
-  });
-  return c.json(result);
-}).get("/:name/history/turn", async (c) => {
-  const name = c.req.param("name");
-  const turnId = c.req.query("turn_id");
+  const turnId = c.req.query("turn_id");
+  const detail = c.req.query("detail") === "1";
   const db = await getDb();
+  const typeFilter = detail ? void 0 : sql3`${mindHistory.type} IN ('inbound','outbound','tool_use','tool_result','text','thinking','activity')`;
+  let rows;
   if (turnId) {
-    const rows2 = await db.select().from(mindHistory).where(
-      and4(
-        eq5(mindHistory.mind, name),
-        eq5(mindHistory.turn_id, turnId),
-        sql2`${mindHistory.type} IN ('inbound','outbound','tool_use','tool_result','text','thinking')`
+    rows = await db.select().from(mindHistory).where(and5(eq6(mindHistory.mind, name), eq6(mindHistory.turn_id, turnId), typeFilter)).orderBy(mindHistory.id);
+  } else {
+    const session = c.req.query("session");
+    const fromId = parseInt(c.req.query("from_id") ?? "", 10);
+    const toId = parseInt(c.req.query("to_id") ?? "", 10);
+    if (!session || Number.isNaN(fromId) || Number.isNaN(toId)) {
+      return c.json({ error: "turn_id, or session with from_id and to_id, required" }, 400);
+    }
+    rows = await db.select().from(mindHistory).where(
+      and5(
+        eq6(mindHistory.mind, name),
+        eq6(mindHistory.session, session),
+        sql3`${mindHistory.id} >= ${fromId}`,
+        sql3`${mindHistory.id} <= ${toId}`,
+        typeFilter
       )
     ).orderBy(mindHistory.id);
-    return c.json(rows2);
   }
-  const session = c.req.query("session");
-  const fromId = parseInt(c.req.query("from_id") ?? "", 10);
-  const toId = parseInt(c.req.query("to_id") ?? "", 10);
-  if (!session || Number.isNaN(fromId) || Number.isNaN(toId)) {
-    return c.json({ error: "turn_id, or session with from_id and to_id, required" }, 400);
-  }
-  const rows = await db.select().from(mindHistory).where(
-    and4(
-      eq5(mindHistory.mind, name),
-      eq5(mindHistory.session, session),
-      sql2`${mindHistory.id} >= ${fromId}`,
-      sql2`${mindHistory.id} <= ${toId}`,
-      sql2`${mindHistory.type} IN ('inbound','outbound','tool_use','tool_result','text','thinking')`
-    )
-  ).orderBy(mindHistory.id);
   return c.json(rows);
 }).get("/:name/history/cross-session", async (c) => {
   const name = c.req.param("name");
@@ -5397,14 +5888,14 @@ ${user.trimEnd()}
   let sinceTimestamp = null;
   if (currentSession) {
     const lastTurn = await db.select({ turn_id: mindHistory.turn_id }).from(mindHistory).where(
-      and4(
-        eq5(mindHistory.mind, name),
-        eq5(mindHistory.session, currentSession),
-        sql2`${mindHistory.turn_id} IS NOT NULL`
+      and5(
+        eq6(mindHistory.mind, name),
+        eq6(mindHistory.session, currentSession),
+        sql3`${mindHistory.turn_id} IS NOT NULL`
       )
-    ).orderBy(desc3(mindHistory.created_at)).limit(1);
+    ).orderBy(desc4(mindHistory.created_at)).limit(1);
     if (lastTurn.length > 0 && lastTurn[0].turn_id) {
-      const firstEvent = await db.select({ created_at: mindHistory.created_at }).from(mindHistory).where(eq5(mindHistory.turn_id, lastTurn[0].turn_id)).orderBy(mindHistory.created_at).limit(1);
+      const firstEvent = await db.select({ created_at: mindHistory.created_at }).from(mindHistory).where(eq6(mindHistory.turn_id, lastTurn[0].turn_id)).orderBy(mindHistory.created_at).limit(1);
       if (firstEvent.length > 0) {
         sinceTimestamp = firstEvent[0].created_at;
       }
@@ -5414,18 +5905,18 @@ ${user.trimEnd()}
     sinceTimestamp = new Date(Date.now() - 36e5).toISOString().replace("T", " ").slice(0, 19);
   }
   const conditions = [
-    eq5(mindHistory.mind, name),
-    eq5(mindHistory.type, "summary"),
-    sql2`${mindHistory.created_at} > ${sinceTimestamp}`
+    eq6(mindHistory.mind, name),
+    eq6(mindHistory.type, "summary"),
+    sql3`${mindHistory.created_at} > ${sinceTimestamp}`
   ];
   if (currentSession) {
-    conditions.push(sql2`${mindHistory.session} != ${currentSession}`);
+    conditions.push(sql3`${mindHistory.session} != ${currentSession}`);
   }
   const rows = await db.select({
     session: mindHistory.session,
     content: mindHistory.content,
     created_at: mindHistory.created_at
-  }).from(mindHistory).where(and4(...conditions)).orderBy(desc3(mindHistory.created_at)).limit(50);
+  }).from(mindHistory).where(and5(...conditions)).orderBy(desc4(mindHistory.created_at)).limit(50);
   if (rows.length === 0) {
     return c.json({ context: null });
   }
@@ -5445,40 +5936,40 @@ ${lines.join("\n")}` });
   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 = [eq5(mindHistory.mind, name)];
+  const conditions = [eq6(mindHistory.mind, name)];
   if (channel) {
-    conditions.push(eq5(mindHistory.channel, channel));
+    conditions.push(eq6(mindHistory.channel, channel));
   }
   if (session) {
-    conditions.push(eq5(mindHistory.session, session));
+    conditions.push(eq6(mindHistory.session, session));
   }
   const effectivePreset = full ? "all" : preset;
   switch (effectivePreset) {
     case "all":
       break;
     case "conversation":
-      conditions.push(sql2`${mindHistory.type} IN ('summary','inbound','outbound','tool_use')`);
+      conditions.push(sql3`${mindHistory.type} IN ('summary','inbound','outbound','tool_use')`);
       break;
     case "detailed":
       conditions.push(
-        sql2`${mindHistory.type} IN ('summary','inbound','outbound','tool_use','tool_result','text','thinking')`
+        sql3`${mindHistory.type} IN ('summary','inbound','outbound','tool_use','tool_result','text','thinking')`
       );
       break;
     default:
-      conditions.push(sql2`${mindHistory.type} IN ('summary')`);
+      conditions.push(sql3`${mindHistory.type} IN ('summary')`);
       break;
   }
-  const rows = await db.select().from(mindHistory).where(and4(...conditions)).orderBy(desc3(mindHistory.created_at)).limit(limit).offset(offset);
+  const rows = await db.select().from(mindHistory).where(and5(...conditions)).orderBy(desc4(mindHistory.created_at)).limit(limit).offset(offset);
   return c.json(rows);
 });
 var minds_default = app13;
 
 // src/web/api/prompts.ts
 import { zValidator as zValidator6 } from "@hono/zod-validator";
-import { eq as eq6, sql as sql3 } from "drizzle-orm";
-import { Hono as Hono15 } from "hono";
+import { eq as eq7, sql as sql4 } from "drizzle-orm";
+import { Hono as Hono16 } from "hono";
 import { z as z6 } from "zod";
-var app14 = new Hono15().get("/", async (c) => {
+var app14 = new Hono16().get("/", async (c) => {
   let rows;
   try {
     const db = await getDb();
@@ -5508,9 +5999,9 @@ var app14 = new Hono15().get("/", async (c) => {
   }
   const { content } = c.req.valid("json");
   const db = await getDb();
-  await db.insert(systemPrompts).values({ key, content, updated_at: sql3`(datetime('now'))` }).onConflictDoUpdate({
+  await db.insert(systemPrompts).values({ key, content, updated_at: sql4`(datetime('now'))` }).onConflictDoUpdate({
     target: systemPrompts.key,
-    set: { content, updated_at: sql3`(datetime('now'))` }
+    set: { content, updated_at: sql4`(datetime('now'))` }
   });
   return c.json({ ok: true });
 }).delete("/:key", requireAdmin, async (c) => {
@@ -5519,7 +6010,7 @@ var app14 = new Hono15().get("/", async (c) => {
     return c.json({ error: "Unknown prompt key" }, 404);
   }
   const db = await getDb();
-  await db.delete(systemPrompts).where(eq6(systemPrompts.key, key));
+  await db.delete(systemPrompts).where(eq7(systemPrompts.key, key));
   return c.json({ ok: true });
 });
 var prompts_default = app14;
@@ -5527,7 +6018,7 @@ var prompts_default = app14;
 // src/web/api/public-files.ts
 import { readdir, readFile as readFile2, stat as stat2 } from "fs/promises";
 import { extname as extname3, resolve as resolve13 } from "path";
-import { Hono as Hono16 } from "hono";
+import { Hono as Hono17 } from "hono";
 var MAX_FILE_SIZE = 50 * 1024 * 1024;
 async function resolvePublicRoot(name) {
   if (name === "_system") return resolve13(voluteHome(), "shared");
@@ -5568,7 +6059,7 @@ async function listDir(dirPath) {
     type: e.isDirectory() ? "directory" : "file"
   }));
 }
-var app15 = new Hono16().get("/:name/", async (c) => {
+var app15 = new Hono17().get("/:name/", async (c) => {
   const name = c.req.param("name");
   const publicRoot = await resolvePublicRoot(name);
   if (!publicRoot) return c.json({ error: "Not found" }, 404);
@@ -5615,7 +6106,7 @@ var public_files_default = app15;
 
 // src/web/api/schedules.ts
 import { CronExpressionParser } from "cron-parser";
-import { Hono as Hono17 } from "hono";
+import { Hono as Hono18 } from "hono";
 var slog2 = logger_default.child("schedules");
 function readSchedules(name) {
   return readVoluteConfig(mindDir(name))?.schedules ?? [];
@@ -5633,7 +6124,7 @@ function writeSchedules(name, schedules) {
     data: { schedules }
   });
 }
-var app16 = new Hono17().get("/:name/clock/status", async (c) => {
+var app16 = new Hono18().get("/:name/clock/status", async (c) => {
   const name = c.req.param("name");
   if (!await findMind(name)) return c.json({ error: "Mind not found" }, 404);
   const sleepManager = getSleepManagerIfReady();
@@ -5643,6 +6134,7 @@ var app16 = new Hono17().get("/:name/clock/status", async (c) => {
   const now = /* @__PURE__ */ new Date();
   const in24h = new Date(now.getTime() + 24 * 60 * 6e4);
   const upcoming = [];
+  const previous = [];
   for (const s of schedules) {
     if (!s.enabled) continue;
     if (s.fireAt) {
@@ -5660,10 +6152,17 @@ var app16 = new Hono17().get("/:name/clock/status", async (c) => {
       } catch {
         slog2.warn(`invalid cron "${s.cron}" for schedule "${s.id}" of ${name}`);
       }
+      try {
+        const prevInterval = CronExpressionParser.parse(s.cron);
+        const prev = prevInterval.prev().toDate();
+        previous.push({ id: s.id, at: prev.toISOString() });
+      } catch {
+      }
     }
   }
   upcoming.sort((a, b) => a.at.localeCompare(b.at));
-  return c.json({ sleep: sleepState, sleepConfig, schedules, upcoming });
+  previous.sort((a, b) => b.at.localeCompare(a.at));
+  return c.json({ sleep: sleepState, sleepConfig, schedules, upcoming, previous });
 }).get("/:name/schedules", async (c) => {
   const name = c.req.param("name");
   if (!await findMind(name)) return c.json({ error: "Mind not found" }, 404);
@@ -5791,7 +6290,7 @@ var app16 = new Hono17().get("/:name/clock/status", async (c) => {
   const body = await c.req.text();
   const message = `[webhook: ${event}] ${body}`;
   try {
-    const { sendSystemMessage } = await import("./system-chat-NPYFYZVI.js");
+    const { sendSystemMessage } = await import("./system-chat-JAPOJ3KE.js");
     await sendSystemMessage(name, message);
     return c.json({ ok: true });
   } catch (err) {
@@ -5805,10 +6304,10 @@ var schedules_default = app16;
 import { mkdirSync as mkdirSync7 } from "fs";
 import { homedir as homedir2 } from "os";
 import { resolve as resolve14 } from "path";
-import { Hono as Hono18 } from "hono";
+import { Hono as Hono19 } from "hono";
 import { setCookie as setCookie2 } from "hono/cookie";
 var DEFAULT_API_URL2 = "https://volute.systems";
-var setup = new Hono18();
+var setup = new Hono19();
 function writeSetupConfig(systemName, description) {
   const configHome = process.env.VOLUTE_HOME ?? resolve14(homedir2(), ".volute");
   const mindsDir = resolve14(configHome, "minds");
@@ -5844,7 +6343,7 @@ setup.get("/status", async (c) => {
   let hasAccount = false;
   if (hasSystem) {
     try {
-      const { listUsersByType: listUsersByType2 } = await import("./auth-6DMGES3I.js");
+      const { listUsersByType: listUsersByType2 } = await import("./auth-GKCDSO4T.js");
       const brains = await listUsersByType2("brain");
       hasAccount = brains.length > 0;
     } catch (err) {
@@ -6029,7 +6528,7 @@ setup.post("/account", async (c) => {
     }
   }
   try {
-    const { createUser: createUser2, updateUserProfile: updateUserProfile2 } = await import("./auth-6DMGES3I.js");
+    const { createUser: createUser2, updateUserProfile: updateUserProfile2 } = await import("./auth-GKCDSO4T.js");
     const user = await createUser2(body.username.trim(), body.password);
     if (body.displayName?.trim()) {
       await updateUserProfile2(user.id, { display_name: body.displayName.trim() });
@@ -6075,13 +6574,13 @@ setup.post("/models", async (c) => {
     return c.json({ error: "Spirit model is required" }, 400);
   }
   try {
-    const { setEnabledModels: setEnabledModels2, setUtilityModel } = await import("./ai-service-ZIPCV3MX.js");
-    setEnabledModels2(body.models);
+    const { setEnabledModels: setEnabledModels3, setUtilityModel: setUtilityModel2 } = await import("./ai-service-SBY2WG7O.js");
+    setEnabledModels3(body.models);
     const config2 = readGlobalConfig();
     config2.spiritModel = body.spiritModel.trim();
     writeGlobalConfig(config2);
     if (body.utilityModel?.trim()) {
-      setUtilityModel(body.utilityModel.trim());
+      setUtilityModel2(body.utilityModel.trim());
     }
     return c.json({ ok: true });
   } catch (err) {
@@ -6093,8 +6592,8 @@ setup.post("/complete", async (c) => {
     return c.json({ error: "Setup already complete" }, 400);
   }
   try {
-    const { ensureSpiritProject, syncSpiritTemplate } = await import("./spirit-N4W4UQRH.js");
-    const { startSpiritFull } = await import("./mind-service-AV273WT4.js");
+    const { ensureSpiritProject, syncSpiritTemplate } = await import("./spirit-VRONKFMF.js");
+    const { startSpiritFull } = await import("./mind-service-2MQ6UK5N.js");
     await ensureSpiritProject();
     await syncSpiritTemplate();
     const warnings = [];
@@ -6110,8 +6609,8 @@ setup.post("/complete", async (c) => {
     }
     let spiritConversationId;
     try {
-      const { getOrCreateMindUser: getOrCreateMindUser2, listUsersByType: listUsersByType2 } = await import("./auth-6DMGES3I.js");
-      const { createConversation: createConversation6, findDMConversation: findDMConversation2 } = await import("./conversations-3O5O6AS3.js");
+      const { getOrCreateMindUser: getOrCreateMindUser2, listUsersByType: listUsersByType2 } = await import("./auth-GKCDSO4T.js");
+      const { createConversation: createConversation6, findDMConversation: findDMConversation2 } = await import("./conversations-AWI5SZW2.js");
       const spiritUser = await getOrCreateMindUser2("volute");
       const brains = await listUsersByType2("brain");
       const admin2 = brains.find((u) => u.role === "admin");
@@ -6134,8 +6633,8 @@ setup.post("/complete", async (c) => {
     logger_default.info("setup complete state", { spiritConversationId, spiritStarted });
     if (spiritConversationId && spiritStarted) {
       try {
-        const { deliverMessage: deliverMessage2 } = await import("./message-delivery-2FIM7QKO.js");
-        const { listUsersByType: listUsers6 } = await import("./auth-6DMGES3I.js");
+        const { deliverMessage: deliverMessage2 } = await import("./message-delivery-DFF5SJRM.js");
+        const { listUsersByType: listUsers6 } = await import("./auth-GKCDSO4T.js");
         const admins = await listUsers6("brain");
         const admin2 = admins.find((u) => u.role === "admin");
         const adminName = admin2?.display_name || admin2?.username || "the admin";
@@ -6172,8 +6671,8 @@ setup.post("/complete", async (c) => {
 var setup_default = setup;
 
 // src/web/api/shared.ts
-import { Hono as Hono19 } from "hono";
-var app17 = new Hono19().post("/:name/shared/merge", requireAdmin, async (c) => {
+import { Hono as Hono20 } from "hono";
+var app17 = new Hono20().post("/:name/shared/merge", requireAdmin, async (c) => {
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
@@ -6198,8 +6697,8 @@ import { existsSync as existsSync10, mkdtempSync, readdirSync as readdirSync3, r
 import { tmpdir } from "os";
 import { join, resolve as resolve15 } from "path";
 import AdmZip from "adm-zip";
-import { Hono as Hono20 } from "hono";
-var app18 = new Hono20().get("/", async (c) => {
+import { Hono as Hono21 } from "hono";
+var app18 = new Hono21().get("/", async (c) => {
   const skills = await listSharedSkills();
   return c.json(skills);
 }).get("/defaults/list", async (c) => {
@@ -6314,14 +6813,14 @@ var skills_default = app18;
 
 // src/web/api/typing.ts
 import { zValidator as zValidator7 } from "@hono/zod-validator";
-import { Hono as Hono21 } from "hono";
+import { Hono as Hono22 } from "hono";
 import { z as z7 } from "zod";
 var typingSchema = z7.object({
   channel: z7.string().min(1),
   sender: z7.string().min(1),
   active: z7.boolean()
 });
-var app19 = new Hono21().post("/:name/typing", zValidator7("json", typingSchema), (c) => {
+var app19 = new Hono22().post("/:name/typing", zValidator7("json", typingSchema), (c) => {
   const { channel, sender, active } = c.req.valid("json");
   const map = getTypingMap();
   if (active) {
@@ -6345,9 +6844,9 @@ var typing_default = app19;
 
 // src/web/api/update.ts
 import { spawn as spawn3 } from "child_process";
-import { Hono as Hono22 } from "hono";
+import { Hono as Hono23 } from "hono";
 var bin;
-var app20 = new Hono22().get("/update", async (c) => {
+var app20 = new Hono23().get("/update", async (c) => {
   const result = await checkForUpdate();
   return c.json(result);
 }).post("/update", requireAdmin, async (c) => {
@@ -6364,219 +6863,15 @@ var app20 = new Hono22().get("/update", async (c) => {
 });
 var update_default = app20;
 
-// src/web/api/v1/chat.ts
-import { zValidator as zValidator8 } from "@hono/zod-validator";
-import { Hono as Hono23 } from "hono";
-import { streamSSE as streamSSE4 } from "hono/streaming";
-import { z as z8 } from "zod";
-async function fanOutToMinds(opts) {
-  const participants = await getParticipants(opts.conversationId);
-  const mindParticipants = participants.filter(
-    (p) => p.userType === "mind" || p.userType === "system"
-  );
-  const participantNames = participants.map((p) => p.username);
-  const isDM = opts.isDM ?? participants.length === 2;
-  const { getMindManager: getMindManager2 } = await import("./mind-manager-BNCMGYXW.js");
-  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-53DZOWW7.js");
-  const manager = getMindManager2();
-  const sm = getSleepManagerIfReady2();
-  const targetMinds = mindParticipants.map((ap) => {
-    const key = opts.targetName ? opts.targetName(ap.username) : ap.username;
-    if (manager.isRunning(key) || sm?.isSleeping(ap.username)) return ap.username;
-    return null;
-  }).filter((n) => n !== null && n !== opts.senderName);
-  function slugForMind(mindUsername) {
-    return buildVoluteSlug({
-      participants,
-      mindUsername,
-      convTitle: opts.convTitle,
-      conversationId: opts.conversationId,
-      ...opts.slugExtra
-    });
-  }
-  for (const mindName of targetMinds) {
-    const target = opts.targetName ? opts.targetName(mindName) : mindName;
-    const channel = slugForMind(mindName);
-    const typingMap = getTypingMap();
-    const currentlyTyping = typingMap.get(channel).filter((name) => participantNames.includes(name));
-    deliverMessage(target, {
-      content: opts.contentBlocks,
-      channel,
-      conversationId: opts.conversationId,
-      sender: opts.senderName,
-      participants: participantNames,
-      participantCount: participants.length,
-      isDM,
-      ...currentlyTyping.length > 0 ? { typing: currentlyTyping } : {}
-    }).catch((err) => {
-      logger_default.warn("[v1-chat] delivery failed", logger_default.errorData(err));
-    });
-  }
-}
-var mindChatSchema = z8.object({
-  message: z8.string().optional(),
-  conversationId: z8.string().optional(),
-  sender: z8.string().optional(),
-  images: z8.array(z8.object({ media_type: z8.string(), data: z8.string() })).optional()
-});
-var unifiedChatSchema = z8.object({
-  message: z8.string().optional(),
-  conversationId: z8.string(),
-  images: z8.array(z8.object({ media_type: z8.string(), data: z8.string() })).optional()
-});
-var app21 = new Hono23().use("*", authMiddleware).post("/minds/:name/chat", zValidator8("json", mindChatSchema), async (c) => {
-  const name = c.req.param("name");
-  const baseName = await getBaseName(name);
-  const entry = await findMind(baseName);
-  if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const body = c.req.valid("json");
-  if (!body.message && (!body.images || body.images.length === 0)) {
-    return c.json({ error: "message or images required" }, 400);
-  }
-  const user = c.get("user");
-  const mindUser = await getOrCreateMindUser(baseName);
-  const senderName = user.id === 0 && body.sender ? body.sender : user.username;
-  let conversationId = body.conversationId;
-  if (conversationId) {
-    if (user.id !== 0 && !await isParticipantOrOwner(conversationId, user.id)) {
-      return c.json({ error: "Conversation not found" }, 404);
-    }
-  } else {
-    const participantIds = [];
-    if (user.id !== 0) {
-      participantIds.push(user.id);
-    } else if (body.sender) {
-      const senderMind = await findMind(body.sender);
-      if (senderMind) {
-        const senderMindUser = await getOrCreateMindUser(body.sender);
-        participantIds.push(senderMindUser.id);
-      }
-    }
-    participantIds.push(mindUser.id);
-    if (participantIds.length === 2) {
-      const existing = await findDMConversation(baseName, participantIds);
-      if (existing) conversationId = existing;
-    }
-    if (!conversationId) {
-      const participantNames = /* @__PURE__ */ new Set([senderName, baseName]);
-      const title = [...participantNames].join(", ");
-      const conv2 = await createConversation(baseName, "volute", {
-        userId: user.id !== 0 ? user.id : void 0,
-        title,
-        participantIds
-      });
-      conversationId = conv2.id;
-    }
-  }
-  const conv = await getConversation(conversationId);
-  const convTitle = conv?.title ?? null;
-  const contentBlocks = [];
-  if (body.message) contentBlocks.push({ type: "text", text: body.message });
-  if (body.images) {
-    for (const img of body.images) {
-      contentBlocks.push({ type: "image", media_type: img.media_type, data: img.data });
-    }
-  }
-  const senderIsMind = user.id === 0 && body.sender && await findMind(body.sender);
-  const v1MindSession = c.get("mindSession");
-  let v1SourceEventId;
-  let v1TurnId;
-  if (senderIsMind) {
-    v1SourceEventId = getLastToolUseEventId(body.sender, v1MindSession);
-    v1TurnId = getActiveTurnId(body.sender, v1MindSession);
-  }
-  await addMessage(conversationId, "user", senderName, contentBlocks, {
-    sourceEventId: v1SourceEventId,
-    turnId: v1TurnId
-  });
-  const isDM = conv?.type === "dm";
-  await fanOutToMinds({
-    conversationId,
-    contentBlocks,
-    senderName,
-    convTitle,
-    isDM,
-    slugExtra: conv ? { convType: conv.type, convName: conv.name } : void 0,
-    targetName: (username) => username === baseName ? name : username
-  });
-  return c.json({ ok: true, conversationId });
-}).get("/minds/:name/conversations/:id/events", async (c) => {
-  const conversationId = c.req.param("id");
-  const user = c.get("user");
-  if (user.id !== 0 && !await isParticipantOrOwner(conversationId, user.id)) {
-    return c.json({ error: "Conversation not found" }, 404);
-  }
-  return streamSSE4(c, async (stream) => {
-    const unsubscribe = subscribe2(conversationId, (event) => {
-      stream.writeSSE({ data: JSON.stringify(event) }).catch((err) => {
-        if (!stream.aborted) logger_default.error("[v1-chat] SSE write error:", logger_default.errorData(err));
-      });
-    });
-    const keepAlive = setInterval(() => {
-      stream.writeSSE({ data: "" }).catch((err) => {
-        if (!stream.aborted) logger_default.error("[v1-chat] SSE ping error:", logger_default.errorData(err));
-      });
-    }, 15e3);
-    await new Promise((resolve20) => {
-      stream.onAbort(() => {
-        unsubscribe();
-        clearInterval(keepAlive);
-        resolve20();
-      });
-    });
-  });
-}).post("/chat", zValidator8("json", unifiedChatSchema), async (c) => {
-  const user = c.get("user");
-  const body = c.req.valid("json");
-  if (!body.message && (!body.images || body.images.length === 0)) {
-    return c.json({ error: "message or images required" }, 400);
-  }
-  const conv = await getConversation(body.conversationId);
-  if (!conv) return c.json({ error: "Conversation not found" }, 404);
-  if (user.id !== 0 && !await isParticipantOrOwner(body.conversationId, user.id)) {
-    return c.json({ error: "Conversation not found" }, 404);
-  }
-  const senderName = user.username;
-  const contentBlocks = [];
-  if (body.message) contentBlocks.push({ type: "text", text: body.message });
-  if (body.images) {
-    for (const img of body.images) {
-      contentBlocks.push({ type: "image", media_type: img.media_type, data: img.data });
-    }
-  }
-  const unifiedV1Session = c.get("mindSession");
-  let unifiedV1SourceEventId;
-  let unifiedV1TurnId;
-  if (user.user_type === "mind") {
-    unifiedV1SourceEventId = getLastToolUseEventId(senderName, unifiedV1Session);
-    unifiedV1TurnId = getActiveTurnId(senderName, unifiedV1Session);
-  }
-  await addMessage(body.conversationId, "user", senderName, contentBlocks, {
-    sourceEventId: unifiedV1SourceEventId,
-    turnId: unifiedV1TurnId
-  });
-  const isDM = conv.type === "dm";
-  await fanOutToMinds({
-    conversationId: body.conversationId,
-    contentBlocks,
-    senderName,
-    convTitle: conv.title,
-    isDM,
-    slugExtra: { convType: conv.type, convName: conv.name }
-  });
-  return c.json({ ok: true, conversationId: body.conversationId });
-});
-var chat_default = app21;
-
 // src/web/api/v1/conversations.ts
-import { zValidator as zValidator9 } from "@hono/zod-validator";
+import { zValidator as zValidator8 } from "@hono/zod-validator";
 import { Hono as Hono24 } from "hono";
-import { z as z9 } from "zod";
-var createSchema = z9.object({
-  title: z9.string().optional(),
-  participantNames: z9.array(z9.string()).min(1)
+import { z as z8 } from "zod";
+var createSchema = z8.object({
+  title: z8.string().optional(),
+  participantNames: z8.array(z8.string()).min(1)
 });
-var app22 = new Hono24().use("*", authMiddleware).get("/", async (c) => {
+var app21 = new Hono24().use("*", authMiddleware).get("/", async (c) => {
   const user = c.get("user");
   const convs = await listConversationsWithParticipants(user.id);
   return c.json(convs);
@@ -6603,7 +6898,7 @@ var app22 = new Hono24().use("*", authMiddleware).get("/", async (c) => {
   }
   const participants = await getParticipants(id);
   return c.json(participants);
-}).post("/", zValidator9("json", createSchema), async (c) => {
+}).post("/", zValidator8("json", createSchema), async (c) => {
   const user = c.get("user");
   const body = c.req.valid("json");
   const participantIds = /* @__PURE__ */ new Set();
@@ -6627,6 +6922,9 @@ var app22 = new Hono24().use("*", authMiddleware).get("/", async (c) => {
   if (!firstMindName) {
     return c.json({ error: "At least one mind participant is required" }, 400);
   }
+  if (participantIds.size > 2) {
+    return c.json({ error: "Use channels for multi-participant conversations" }, 400);
+  }
   const conv = await createConversation(firstMindName, "volute", {
     userId: user.id !== 0 ? user.id : void 0,
     title: body.title,
@@ -6642,6 +6940,15 @@ var app22 = new Hono24().use("*", authMiddleware).get("/", async (c) => {
   }
   await markConversationRead(user.id, id);
   return c.json({ ok: true });
+}).put("/:id/private", zValidator8("json", z8.object({ private: z8.boolean() })), async (c) => {
+  const id = c.req.param("id");
+  const user = c.get("user");
+  if (!await isParticipantOrOwner(id, user.id)) {
+    return c.json({ error: "Forbidden" }, 403);
+  }
+  const body = c.req.valid("json");
+  await setConversationPrivate(id, body.private);
+  return c.json({ ok: true });
 }).delete("/:id", async (c) => {
   const id = c.req.param("id");
   const user = c.get("user");
@@ -6649,12 +6956,12 @@ var app22 = new Hono24().use("*", authMiddleware).get("/", async (c) => {
   if (!deleted) return c.json({ error: "Conversation not found" }, 404);
   return c.json({ ok: true });
 });
-var conversations_default = app22;
+var conversations_default = app21;
 
 // src/web/api/v1/events.ts
-import { desc as desc4 } from "drizzle-orm";
+import { desc as desc5 } from "drizzle-orm";
 import { Hono as Hono25 } from "hono";
-import { streamSSE as streamSSE5 } from "hono/streaming";
+import { streamSSE as streamSSE4 } from "hono/streaming";
 
 // src/lib/events/brain-presence.ts
 var connections = /* @__PURE__ */ new Map();
@@ -6700,11 +7007,11 @@ function getEventsSince(sinceId) {
 }
 
 // src/web/api/v1/events.ts
-var app23 = new Hono25().use("*", authMiddleware).get("/", async (c) => {
+var app22 = new Hono25().use("*", authMiddleware).get("/", async (c) => {
   const user = c.get("user");
   const since = c.req.query("since");
   const sinceId = since ? Number(since) : 0;
-  return streamSSE5(c, async (stream) => {
+  return streamSSE4(c, async (stream) => {
     const cleanups = [];
     if (user.user_type === "brain") {
       addConnection(user.username);
@@ -6723,7 +7030,7 @@ var app23 = new Hono25().use("*", authMiddleware).get("/", async (c) => {
       let recentActivity = [];
       try {
         const db = await getDb();
-        recentActivity = await db.select().from(activity).orderBy(desc4(activity.created_at)).limit(50);
+        recentActivity = await db.select().from(activity).orderBy(desc5(activity.created_at)).limit(50);
         recentActivity = recentActivity.map((row) => ({
           ...row,
           metadata: row.metadata ? JSON.parse(row.metadata) : null
@@ -6803,7 +7110,7 @@ var app23 = new Hono25().use("*", authMiddleware).get("/", async (c) => {
     }
   });
 });
-var events_default = app23;
+var events_default = app22;
 
 // src/web/api/variants.ts
 import { existsSync as existsSync11, mkdirSync as mkdirSync9, writeFileSync as writeFileSync8 } from "fs";
@@ -6924,7 +7231,7 @@ async function verify2(port) {
 }
 
 // src/web/api/variants.ts
-var app24 = new Hono26().get("/:name/variants", async (c) => {
+var app23 = new Hono26().get("/:name/variants", async (c) => {
   const name = c.req.param("name");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
@@ -7146,19 +7453,19 @@ var app24 = new Hono26().get("/:name/variants", async (c) => {
   await cleanupVariant(variantName, projectRoot, variantEntry.dir, { stop: true });
   return c.json({ ok: true });
 });
-var variants_default = app24;
+var variants_default = app23;
 
 // src/web/api/volute/channels.ts
-import { zValidator as zValidator10 } from "@hono/zod-validator";
+import { zValidator as zValidator9 } from "@hono/zod-validator";
 import { Hono as Hono27 } from "hono";
-import { z as z10 } from "zod";
-var createSchema2 = z10.object({
-  name: z10.string().min(1).max(50).regex(/^[a-z0-9][a-z0-9-]*$/, "Channel names must be lowercase alphanumeric with hyphens")
+import { z as z9 } from "zod";
+var createSchema2 = z9.object({
+  name: z9.string().min(1).max(50).regex(/^[a-z0-9][a-z0-9-]*$/, "Channel names must be lowercase alphanumeric with hyphens")
 });
-var inviteSchema = z10.object({
-  username: z10.string().min(1)
+var inviteSchema = z9.object({
+  username: z9.string().min(1)
 });
-var app25 = new Hono27().get("/", async (c) => {
+var app24 = new Hono27().get("/", async (c) => {
   const user = c.get("user");
   const channels = await listChannels();
   const results = await Promise.all(
@@ -7169,7 +7476,7 @@ var app25 = new Hono27().get("/", async (c) => {
     })
   );
   return c.json(results);
-}).post("/", zValidator10("json", createSchema2), async (c) => {
+}).post("/", zValidator9("json", createSchema2), async (c) => {
   const user = c.get("user");
   const body = c.req.valid("json");
   try {
@@ -7208,7 +7515,7 @@ var app25 = new Hono27().get("/", async (c) => {
   if (!ch) return c.json({ error: "Channel not found" }, 404);
   const participants = await getParticipants(ch.id);
   return c.json(participants);
-}).post("/:name/invite", zValidator10("json", inviteSchema), async (c) => {
+}).post("/:name/invite", zValidator9("json", inviteSchema), async (c) => {
   const name = c.req.param("name");
   const inviter = c.get("user");
   const { username } = c.req.valid("json");
@@ -7228,13 +7535,13 @@ var app25 = new Hono27().get("/", async (c) => {
   ]);
   return c.json({ ok: true });
 });
-var channels_default2 = app25;
+var channels_default2 = app24;
 
 // src/web/api/volute/chat.ts
-import { zValidator as zValidator11 } from "@hono/zod-validator";
+import { zValidator as zValidator10 } from "@hono/zod-validator";
 import { Hono as Hono28 } from "hono";
-import { streamSSE as streamSSE6 } from "hono/streaming";
-import { z as z11 } from "zod";
+import { streamSSE as streamSSE5 } from "hono/streaming";
+import { z as z10 } from "zod";
 
 // src/lib/bridge-outbound.ts
 function extractContent(contentBlocks) {
@@ -7308,15 +7615,15 @@ async function routeDMOutbound(conversationId, senderName, contentBlocks) {
 }
 
 // src/web/api/volute/chat.ts
-async function fanOutToMinds2(opts) {
+async function fanOutToMinds(opts) {
   const participants = await getParticipants(opts.conversationId);
   const mindParticipants = participants.filter(
     (p) => p.userType === "mind" || p.userType === "system"
   );
   const participantNames = participants.map((p) => p.username);
   const isDM = opts.isDM ?? participants.length === 2;
-  const { getMindManager: getMindManager2 } = await import("./mind-manager-BNCMGYXW.js");
-  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-53DZOWW7.js");
+  const { getMindManager: getMindManager2 } = await import("./mind-manager-NBJF5D26.js");
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-JTXSN7NV.js");
   const manager = getMindManager2();
   const sm = getSleepManagerIfReady2();
   const targetMinds = mindParticipants.map((ap) => {
@@ -7352,225 +7659,131 @@ async function fanOutToMinds2(opts) {
     });
   }
 }
-var fileSchema = z11.object({
-  filename: z11.string(),
-  data: z11.string()
+var fileSchema = z10.object({
+  filename: z10.string(),
+  data: z10.string()
   // base64
 });
-var chatSchema = z11.object({
-  message: z11.string().optional(),
-  conversationId: z11.string().optional(),
-  sender: z11.string().optional(),
-  images: z11.array(
-    z11.object({
-      media_type: z11.string(),
-      data: z11.string()
+var chatSchema = z10.object({
+  message: z10.string().optional(),
+  conversationId: z10.string().optional(),
+  targetMind: z10.string().optional(),
+  sender: z10.string().optional(),
+  images: z10.array(
+    z10.object({
+      media_type: z10.string(),
+      data: z10.string()
     })
   ).optional(),
-  files: z11.array(fileSchema).optional()
+  files: z10.array(fileSchema).optional()
 });
-var app26 = new Hono28().post("/:name/chat", zValidator11("json", chatSchema), async (c) => {
-  const name = c.req.param("name");
-  const baseName = await getBaseName(name);
-  const entry = await findMind(baseName);
-  if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const body = c.req.valid("json");
-  if (!body.message && (!body.images || body.images.length === 0) && (!body.files || body.files.length === 0)) {
-    return c.json({ error: "message, images, or files required" }, 400);
-  }
-  const user = c.get("user");
-  const mindUser = await getOrCreateMindUser(baseName);
-  const senderName = user.id === 0 && body.sender ? body.sender : user.username;
-  let conversationId = body.conversationId;
-  if (conversationId) {
-    if (user.id !== 0 && !await isParticipantOrOwner(conversationId, user.id)) {
-      return c.json({ error: "Conversation not found" }, 404);
-    }
-  } else {
-    const participantIds = [];
-    if (user.id !== 0) {
-      participantIds.push(user.id);
-    } else if (body.sender) {
-      if (body.sender === "volute") {
-        const systemUser = await getOrCreateSystemUser();
-        participantIds.push(systemUser.id);
-      } else {
-        const senderMind = await findMind(body.sender);
-        if (senderMind) {
-          const senderMindUser = await getOrCreateMindUser(body.sender);
-          participantIds.push(senderMindUser.id);
+var MAX_FILE_SIZE2 = 50 * 1024 * 1024;
+function stageFilesForMinds(files, targetMinds, senderName) {
+  const notifications = [];
+  for (const file of files) {
+    const pathErr = validateFilePath(file.filename);
+    if (pathErr)
+      return { notifications, error: { message: `Invalid filename: ${pathErr}`, status: 400 } };
+    const content = Buffer.from(file.data, "base64");
+    if (content.length > MAX_FILE_SIZE2) {
+      return {
+        notifications,
+        error: {
+          message: `File too large: ${file.filename} (${formatFileSize(content.length)}, max ${formatFileSize(MAX_FILE_SIZE2)})`,
+          status: 413
         }
-      }
-    }
-    participantIds.push(mindUser.id);
-    if (participantIds.length === 2) {
-      const existing = await findDMConversation(baseName, participantIds);
-      if (existing) {
-        conversationId = existing;
-      }
+      };
     }
-    if (!conversationId) {
-      const participantNames = /* @__PURE__ */ new Set([senderName, baseName]);
-      const title = [...participantNames].join(", ");
-      const conv2 = await createConversation(baseName, "volute", {
-        userId: user.id !== 0 ? user.id : void 0,
-        title,
-        participantIds
-      });
-      conversationId = conv2.id;
-    }
-  }
-  const conv = await getConversation(conversationId);
-  const convTitle = conv?.title ?? null;
-  const fileNotifications = [];
-  if (body.files && body.files.length > 0) {
-    const MAX_FILE_SIZE2 = 50 * 1024 * 1024;
-    for (const file of body.files) {
-      const pathErr = validateFilePath(file.filename);
-      if (pathErr) return c.json({ error: `Invalid filename: ${pathErr}` }, 400);
-      const content = Buffer.from(file.data, "base64");
-      if (content.length > MAX_FILE_SIZE2) {
-        return c.json(
-          {
-            error: `File too large: ${file.filename} (${formatFileSize(content.length)}, max ${formatFileSize(MAX_FILE_SIZE2)})`
-          },
-          413
-        );
-      }
-      const { id } = stageFile(baseName, senderName, file.filename, content, file.filename);
-      fileNotifications.push(
+    for (const mind of targetMinds) {
+      const { id } = stageFile(mind, senderName, file.filename, content, file.filename);
+      notifications.push(
         `[file] ${senderName} sent ${file.filename} (${formatFileSize(content.length)}) \u2014 run: volute chat accept ${id}`
       );
     }
   }
-  const contentBlocks = [];
-  if (body.message) {
-    contentBlocks.push({ type: "text", text: body.message });
-  }
-  for (const note of fileNotifications) {
-    contentBlocks.push({ type: "text", text: note });
-  }
-  if (body.images) {
-    for (const img of body.images) {
-      contentBlocks.push({ type: "image", media_type: img.media_type, data: img.data });
-    }
-  }
-  const senderIsMind = user.id === 0 && body.sender && await findMind(body.sender);
-  const mindSession = c.get("mindSession");
-  let sourceEventId;
-  let turnId;
-  if (senderIsMind) {
-    sourceEventId = getLastToolUseEventId(body.sender, mindSession);
-    turnId = getActiveTurnId(body.sender, mindSession);
-  }
-  await addMessage(conversationId, "user", senderName, contentBlocks, {
-    sourceEventId,
-    turnId
-  });
-  if (senderIsMind) {
-    routeOutboundBridge(conversationId, senderName, contentBlocks).catch((err) => {
-      logger_default.warn("outbound bridge routing failed", logger_default.errorData(err));
-    });
-  }
-  const isDM = conv?.type === "dm";
-  await fanOutToMinds2({
-    conversationId,
-    contentBlocks,
-    senderName,
-    convTitle,
-    isDM,
-    slugExtra: conv ? { convType: conv.type, convName: conv.name } : void 0,
-    targetName: (username) => username === baseName ? name : username
-  });
-  if (senderIsMind && body.message) {
-    const participants = await getParticipants(conversationId);
-    const hasSystemUser = participants.some((p) => p.userType === "system");
-    if (hasSystemUser) {
-      generateSystemReply(conversationId, baseName, body.message).catch(
-        (err) => logger_default.error(`system reply generation failed for ${baseName}`, logger_default.errorData(err))
-      );
-    }
-  }
-  return c.json({ ok: true, conversationId });
-}).get("/:name/conversations/:id/events", async (c) => {
-  const conversationId = c.req.param("id");
-  const user = c.get("user");
-  if (user.id !== 0 && !await isParticipantOrOwner(conversationId, user.id)) {
-    return c.json({ error: "Conversation not found" }, 404);
-  }
-  return streamSSE6(c, async (stream) => {
-    const unsubscribe = subscribe2(conversationId, (event) => {
-      stream.writeSSE({ data: JSON.stringify(event) }).catch((err) => {
-        if (!stream.aborted) console.error("[chat] SSE write error:", err);
-      });
-    });
-    const keepAlive = setInterval(() => {
-      stream.writeSSE({ data: "" }).catch((err) => {
-        if (!stream.aborted) console.error("[chat] SSE ping error:", err);
-      });
-    }, 15e3);
-    await new Promise((resolve20) => {
-      stream.onAbort(() => {
-        unsubscribe();
-        clearInterval(keepAlive);
-        resolve20();
-      });
-    });
-  });
-});
-var unifiedChatSchema2 = z11.object({
-  message: z11.string().optional(),
-  conversationId: z11.string(),
-  images: z11.array(z11.object({ media_type: z11.string(), data: z11.string() })).optional(),
-  files: z11.array(fileSchema).optional()
-});
+  return { notifications };
+}
 var unifiedChatApp = new Hono28().post(
   "/chat",
-  zValidator11("json", unifiedChatSchema2),
+  zValidator10("json", chatSchema),
   async (c) => {
     const user = c.get("user");
     const body = c.req.valid("json");
     if (!body.message && (!body.images || body.images.length === 0) && (!body.files || body.files.length === 0)) {
       return c.json({ error: "message, images, or files required" }, 400);
     }
-    const conv = await getConversation(body.conversationId);
-    if (!conv) return c.json({ error: "Conversation not found" }, 404);
-    if (user.id !== 0 && !await isParticipantOrOwner(body.conversationId, user.id)) {
-      return c.json({ error: "Conversation not found" }, 404);
+    if (!body.conversationId && !body.targetMind) {
+      return c.json({ error: "conversationId or targetMind required" }, 400);
+    }
+    const senderName = user.id === 0 && body.sender ? body.sender : user.username;
+    const senderIsMind = user.id === 0 && body.sender && await findMind(body.sender) || user.user_type === "mind";
+    let baseName;
+    let variantName;
+    let conversationId = body.conversationId;
+    if (body.targetMind) {
+      variantName = body.targetMind;
+      baseName = await getBaseName(body.targetMind);
+      const entry = await findMind(baseName);
+      if (!entry) return c.json({ error: "Mind not found" }, 404);
+      if (conversationId) {
+        if (user.id !== 0 && !await isParticipantOrOwner(conversationId, user.id)) {
+          return c.json({ error: "Conversation not found" }, 404);
+        }
+      } else {
+        const mindUser = await getOrCreateMindUser(baseName);
+        const participantIds = [];
+        if (user.id !== 0) {
+          participantIds.push(user.id);
+        } else if (body.sender) {
+          if (body.sender === "volute") {
+            const systemUser = await getOrCreateSystemUser();
+            participantIds.push(systemUser.id);
+          } else {
+            const senderMind = await findMind(body.sender);
+            if (senderMind) {
+              const senderMindUser = await getOrCreateMindUser(body.sender);
+              participantIds.push(senderMindUser.id);
+            }
+          }
+        }
+        participantIds.push(mindUser.id);
+        if (participantIds.length === 2) {
+          const existing = await findDMConversation(baseName, participantIds);
+          if (existing) {
+            conversationId = existing;
+          }
+        }
+        if (!conversationId) {
+          const participantNames = /* @__PURE__ */ new Set([senderName, baseName]);
+          const title = [...participantNames].join(", ");
+          const conv2 = await createConversation(baseName, "volute", {
+            userId: user.id !== 0 ? user.id : void 0,
+            title,
+            participantIds
+          });
+          conversationId = conv2.id;
+        }
+      }
+    } else {
+      if (user.id !== 0 && !await isParticipantOrOwner(conversationId, user.id)) {
+        return c.json({ error: "Conversation not found" }, 404);
+      }
     }
-    const senderName = user.username;
+    const conv = await getConversation(conversationId);
+    if (!conv) return c.json({ error: "Conversation not found" }, 404);
+    const convTitle = conv.title;
     const fileNotifications = [];
     if (body.files && body.files.length > 0) {
-      const participants = await getParticipants(body.conversationId);
-      const mindParticipants = participants.filter(
-        (p) => p.userType === "mind" && p.username !== senderName
-      );
-      const MAX_FILE_SIZE2 = 50 * 1024 * 1024;
-      for (const file of body.files) {
-        const pathErr = validateFilePath(file.filename);
-        if (pathErr) return c.json({ error: `Invalid filename: ${pathErr}` }, 400);
-        const content = Buffer.from(file.data, "base64");
-        if (content.length > MAX_FILE_SIZE2) {
-          return c.json(
-            {
-              error: `File too large: ${file.filename} (${formatFileSize(content.length)}, max ${formatFileSize(MAX_FILE_SIZE2)})`
-            },
-            413
-          );
-        }
-        for (const mind of mindParticipants) {
-          const { id } = stageFile(
-            mind.username,
-            senderName,
-            file.filename,
-            content,
-            file.filename
-          );
-          fileNotifications.push(
-            `[file] ${senderName} sent ${file.filename} (${formatFileSize(content.length)}) \u2014 run: volute chat accept ${id}`
-          );
-        }
+      let fileTargets;
+      if (baseName) {
+        fileTargets = [baseName];
+      } else {
+        const participants = await getParticipants(conversationId);
+        fileTargets = participants.filter((p) => p.userType === "mind" && p.username !== senderName).map((p) => p.username);
       }
+      const { notifications, error } = stageFilesForMinds(body.files, fileTargets, senderName);
+      if (error) return c.json({ error: error.message }, error.status);
+      fileNotifications.push(...notifications);
     }
     const contentBlocks = [];
     if (body.message) contentBlocks.push({ type: "text", text: body.message });
@@ -7582,55 +7795,90 @@ var unifiedChatApp = new Hono28().post(
         contentBlocks.push({ type: "image", media_type: img.media_type, data: img.data });
       }
     }
-    const unifiedMindSession = c.get("mindSession");
-    let unifiedSourceEventId;
-    let unifiedTurnId;
-    if (user.user_type === "mind") {
-      unifiedSourceEventId = getLastToolUseEventId(senderName, unifiedMindSession);
-      unifiedTurnId = getActiveTurnId(senderName, unifiedMindSession);
-    }
-    await addMessage(body.conversationId, "user", senderName, contentBlocks, {
-      sourceEventId: unifiedSourceEventId,
-      turnId: unifiedTurnId
-    });
-    if (user.user_type === "mind") {
-      routeOutboundBridge(body.conversationId, senderName, contentBlocks).catch((err) => {
+    const message = await addMessage(conversationId, "user", senderName, contentBlocks);
+    let outboundId;
+    if (senderIsMind) {
+      routeOutboundBridge(conversationId, senderName, contentBlocks).catch((err) => {
         logger_default.warn("outbound bridge routing failed", logger_default.errorData(err));
       });
+      const channel = buildVoluteSlug({
+        participants: await getParticipants(conversationId),
+        mindUsername: senderName,
+        convTitle,
+        conversationId,
+        convType: conv.type,
+        convName: conv.name
+      });
+      try {
+        outboundId = await recordOutbound(senderName, channel, extractTextContent(contentBlocks), {
+          messageId: message?.id != null ? String(message.id) : void 0
+        });
+      } catch (err) {
+        logger_default.warn(`recordOutbound failed for ${senderName}`, logger_default.errorData(err));
+      }
     }
     const isDM = conv.type === "dm";
-    await fanOutToMinds2({
-      conversationId: body.conversationId,
+    await fanOutToMinds({
+      conversationId,
       contentBlocks,
       senderName,
-      convTitle: conv.title,
+      convTitle,
       isDM,
-      slugExtra: { convType: conv.type, convName: conv.name }
+      slugExtra: { convType: conv.type, convName: conv.name },
+      // Variant-aware targeting: when targetMind is a variant, route to the variant name
+      targetName: baseName ? (username) => username === baseName ? variantName : username : void 0
     });
-    if (user.user_type === "mind" && body.message) {
-      const participants = await getParticipants(body.conversationId);
+    const systemReplyTarget = baseName ?? senderName;
+    if (senderIsMind && body.message) {
+      const participants = await getParticipants(conversationId);
       const hasSystemUser = participants.some((p) => p.userType === "system");
       if (hasSystemUser) {
-        generateSystemReply(body.conversationId, senderName, body.message).catch(
-          (err) => logger_default.error(`system reply generation failed for ${senderName}`, logger_default.errorData(err))
+        generateSystemReply(conversationId, systemReplyTarget, body.message).catch(
+          (err) => logger_default.error(`system reply generation failed for ${systemReplyTarget}`, logger_default.errorData(err))
         );
       }
     }
-    return c.json({ ok: true, conversationId: body.conversationId });
+    return c.json({ ok: true, conversationId, outboundId });
   }
 );
-var chat_default2 = app26;
+var app25 = new Hono28().get("/:name/conversations/:id/events", async (c) => {
+  const conversationId = c.req.param("id");
+  const user = c.get("user");
+  if (user.id !== 0 && !await isParticipantOrOwner(conversationId, user.id)) {
+    return c.json({ error: "Conversation not found" }, 404);
+  }
+  return streamSSE5(c, async (stream) => {
+    const unsubscribe = subscribe2(conversationId, (event) => {
+      stream.writeSSE({ data: JSON.stringify(event) }).catch((err) => {
+        if (!stream.aborted) console.error("[chat] SSE write error:", err);
+      });
+    });
+    const keepAlive = setInterval(() => {
+      stream.writeSSE({ data: "" }).catch((err) => {
+        if (!stream.aborted) console.error("[chat] SSE ping error:", err);
+      });
+    }, 15e3);
+    await new Promise((resolve20) => {
+      stream.onAbort(() => {
+        unsubscribe();
+        clearInterval(keepAlive);
+        resolve20();
+      });
+    });
+  });
+});
+var chat_default = app25;
 
 // src/web/api/volute/conversations.ts
-import { zValidator as zValidator12 } from "@hono/zod-validator";
+import { zValidator as zValidator11 } from "@hono/zod-validator";
 import { Hono as Hono29 } from "hono";
-import { z as z12 } from "zod";
-var createConvSchema = z12.object({
-  title: z12.string().optional(),
-  participantIds: z12.array(z12.number()).optional(),
-  participantNames: z12.array(z12.string()).optional()
+import { z as z11 } from "zod";
+var createConvSchema = z11.object({
+  title: z11.string().optional(),
+  participantIds: z11.array(z11.number()).optional(),
+  participantNames: z11.array(z11.string()).optional()
 });
-var app27 = new Hono29().get("/:name/conversations", async (c) => {
+var app26 = new Hono29().get("/:name/conversations", async (c) => {
   const name = c.req.param("name");
   const user = c.get("user");
   let lookupId = user.id;
@@ -7641,7 +7889,7 @@ var app27 = new Hono29().get("/:name/conversations", async (c) => {
   const all = await listConversationsForUser(lookupId);
   const convs = all.filter((c2) => c2.mind_name === name || c2.type === "channel");
   return c.json(convs);
-}).post("/:name/conversations", zValidator12("json", createConvSchema), async (c) => {
+}).post("/:name/conversations", zValidator11("json", createConvSchema), async (c) => {
   const name = c.req.param("name");
   const user = c.get("user");
   const body = c.req.valid("json");
@@ -7738,109 +7986,12 @@ var app27 = new Hono29().get("/:name/conversations", async (c) => {
   if (!deleted) return c.json({ error: "Conversation not found" }, 404);
   return c.json({ ok: true });
 });
-var conversations_default2 = app27;
-
-// src/web/api/volute/user-conversations.ts
-import { zValidator as zValidator13 } from "@hono/zod-validator";
-import { Hono as Hono30 } from "hono";
-import { streamSSE as streamSSE7 } from "hono/streaming";
-import { z as z13 } from "zod";
-var createSchema3 = z13.object({
-  title: z13.string().optional(),
-  participantNames: z13.array(z13.string()).min(1)
-});
-var app28 = new Hono30().use("*", authMiddleware).get("/", async (c) => {
-  const user = c.get("user");
-  const convs = await listConversationsWithParticipants(user.id);
-  return c.json(convs);
-}).get("/:id/messages", async (c) => {
-  const id = c.req.param("id");
-  const user = c.get("user");
-  if (user.id !== 0 && !await isParticipantOrOwner(id, user.id)) {
-    return c.json({ error: "Conversation not found" }, 404);
-  }
-  const msgs = await getMessages(id);
-  return c.json(msgs);
-}).post("/", zValidator13("json", createSchema3), async (c) => {
-  const user = c.get("user");
-  const body = c.req.valid("json");
-  const participantIds = /* @__PURE__ */ new Set();
-  if (user.id !== 0) participantIds.add(user.id);
-  let firstMindName;
-  for (const name of body.participantNames) {
-    const existing = await getUserByUsername(name);
-    if (existing) {
-      participantIds.add(existing.id);
-      if (!firstMindName && existing.user_type === "mind") firstMindName = name;
-      continue;
-    }
-    if (await findMind(name)) {
-      const au = await getOrCreateMindUser(name);
-      participantIds.add(au.id);
-      if (!firstMindName) firstMindName = name;
-      continue;
-    }
-    return c.json({ error: `User not found: ${name}` }, 400);
-  }
-  if (!firstMindName) {
-    return c.json({ error: "At least one mind participant is required" }, 400);
-  }
-  if (participantIds.size > 2) {
-    return c.json({ error: "Use channels for multi-participant conversations" }, 400);
-  }
-  const conv = await createConversation(firstMindName, "volute", {
-    userId: user.id !== 0 ? user.id : void 0,
-    title: body.title,
-    participantIds: [...participantIds]
-  });
-  return c.json(conv, 201);
-}).get("/:id/events", async (c) => {
-  const conversationId = c.req.param("id");
-  const user = c.get("user");
-  if (user.id !== 0 && !await isParticipantOrOwner(conversationId, user.id)) {
-    return c.json({ error: "Conversation not found" }, 404);
-  }
-  return streamSSE7(c, async (stream) => {
-    const unsubscribe = subscribe2(conversationId, (event) => {
-      stream.writeSSE({ data: JSON.stringify(event) }).catch((err) => {
-        if (!stream.aborted) console.error("[chat] SSE write error:", err);
-      });
-    });
-    const keepAlive = setInterval(() => {
-      stream.writeSSE({ data: "" }).catch((err) => {
-        if (!stream.aborted) console.error("[chat] SSE ping error:", err);
-      });
-    }, 15e3);
-    await new Promise((resolve20) => {
-      stream.onAbort(() => {
-        unsubscribe();
-        clearInterval(keepAlive);
-        resolve20();
-      });
-    });
-  });
-}).put("/:id/private", zValidator13("json", z13.object({ private: z13.boolean() })), async (c) => {
-  const id = c.req.param("id");
-  const user = c.get("user");
-  if (!await isParticipantOrOwner(id, user.id)) {
-    return c.json({ error: "Forbidden" }, 403);
-  }
-  const body = c.req.valid("json");
-  await setConversationPrivate(id, body.private);
-  return c.json({ ok: true });
-}).delete("/:id", async (c) => {
-  const id = c.req.param("id");
-  const user = c.get("user");
-  const deleted = await deleteConversationForUser(id, user.id);
-  if (!deleted) return c.json({ error: "Conversation not found" }, 404);
-  return c.json({ ok: true });
-});
-var user_conversations_default = app28;
+var conversations_default2 = app26;
 
 // src/web/app.ts
 var httpLog = logger_default.child("http");
-var app29 = new Hono31();
-app29.onError((err, c) => {
+var app27 = new Hono30();
+app27.onError((err, c) => {
   if (err instanceof HTTPException) {
     return err.getResponse();
   }
@@ -7851,10 +8002,10 @@ app29.onError((err, c) => {
   });
   return c.json({ error: "Internal server error" }, 500);
 });
-app29.notFound((c) => {
+app27.notFound((c) => {
   return c.json({ error: "Not found" }, 404);
 });
-app29.use("*", async (c, next) => {
+app27.use("*", async (c, next) => {
   const start = Date.now();
   await next();
   const duration = Date.now() - start;
@@ -7865,7 +8016,7 @@ app29.use("*", async (c, next) => {
     httpLog.debug("request", data);
   }
 });
-app29.get("/api/health", (c) => {
+app27.get("/api/health", (c) => {
   let version = "unknown";
   let cached = null;
   try {
@@ -7880,39 +8031,39 @@ app29.get("/api/health", (c) => {
     ...cached?.updateAvailable ? { updateAvailable: true, latest: cached.latest } : {}
   });
 });
-app29.use("/api/*", bodyLimit({ maxSize: 10 * 1024 * 1024 }));
-app29.use("/api/*", csrf());
-app29.use("/api/activity/*", authMiddleware);
-app29.use("/api/minds/*", authMiddleware);
-app29.use("/api/conversations/*", authMiddleware);
-app29.use("/api/volute/*", authMiddleware);
-app29.use("/api/system/*", authMiddleware);
-app29.use("/api/env/*", authMiddleware);
-app29.use("/api/prompts/*", authMiddleware);
-app29.use("/api/skills/*", authMiddleware);
-app29.use("/api/extensions/*", authMiddleware);
-app29.use("/api/bridges/*", authMiddleware);
-app29.use("/api/config/*", authMiddleware);
-app29.use("/api/v1/*", authMiddleware);
-app29.route("/api/setup", setup_default);
-app29.route("/public", public_files_default);
-app29.route("/api/config", config_default);
-var routes = app29.route("/api/activity", activity_default).route("/api/keys", keys_default).route("/api/auth", auth_default).route("/api/system", system_default).route("/api/system", update_default).route("/api/minds", minds_default).route("/api/minds", chat_default2).route("/api/minds", schedules_default).route("/api/minds", logs_default).route("/api/minds", typing_default).route("/api/minds", variants_default).route("/api/minds", file_sharing_default).route("/api/minds", files_default).route("/api/minds", channels_default).route("/api/minds", shared_default).route("/api/minds", env_default).route("/api/minds", mind_skills_default).route("/api/minds", conversations_default2).route("/api/env", sharedEnvApp).route("/api/prompts", prompts_default).route("/api/skills", skills_default).route("/api/conversations", user_conversations_default).route("/api/volute/channels", channels_default2).route("/api/volute", unifiedChatApp).route("/api/bridges", bridges_default).route("/api/extensions", extensions_default).route("/api/v1/conversations", conversations_default).route("/api/v1/events", events_default).route("/api/v1", chat_default);
-app29.route("/api/v1/minds", minds_default);
-app29.route("/api/v1/minds", typing_default);
-app29.route("/api/v1/minds", variants_default);
-app29.route("/api/v1/minds", files_default);
-app29.route("/api/v1/minds", env_default);
-app29.route("/api/v1/minds", mind_skills_default);
-app29.route("/api/v1/minds", schedules_default);
-app29.route("/api/v1/minds", logs_default);
-app29.route("/api/v1/system", system_default);
-app29.route("/api/v1/system", update_default);
-app29.route("/api/v1/prompts", prompts_default);
-app29.route("/api/v1/skills", skills_default);
-app29.route("/api/v1/env", sharedEnvApp);
-app29.route("/api/v1/channels", channels_default2);
-var app_default = app29;
+app27.use("/api/*", bodyLimit({ maxSize: 10 * 1024 * 1024 }));
+app27.use("/api/*", csrf());
+app27.use("/api/activity/*", authMiddleware);
+app27.use("/api/minds/*", authMiddleware);
+app27.use("/api/conversations/*", authMiddleware);
+app27.use("/api/system/*", authMiddleware);
+app27.use("/api/env/*", authMiddleware);
+app27.use("/api/prompts/*", authMiddleware);
+app27.use("/api/skills/*", authMiddleware);
+app27.use("/api/extensions/*", authMiddleware);
+app27.use("/api/bridges/*", authMiddleware);
+app27.use("/api/config/*", authMiddleware);
+app27.use("/api/v1/*", authMiddleware);
+app27.route("/api/setup", setup_default);
+app27.route("/public", public_files_default);
+app27.route("/api/config", config_default);
+var routes = app27.route("/api/activity", activity_default).route("/api/keys", keys_default).route("/api/auth", auth_default).route("/api/system", system_default).route("/api/system", update_default).route("/api/minds", minds_default).route("/api/minds", chat_default).route("/api/minds", schedules_default).route("/api/minds", logs_default).route("/api/minds", typing_default).route("/api/minds", variants_default).route("/api/minds", file_sharing_default).route("/api/minds", files_default).route("/api/minds", channels_default).route("/api/minds", shared_default).route("/api/minds", env_default).route("/api/minds", mind_skills_default).route("/api/minds", conversations_default2).route("/api/env", sharedEnvApp).route("/api/prompts", prompts_default).route("/api/skills", skills_default).route("/api/bridges", bridges_default).route("/api/extensions", extensions_default).route("/api/v1/conversations", conversations_default).route("/api/v1/events", events_default).route("/api/v1", unifiedChatApp).route("/api/v1/channels", channels_default2).route("/api/v1/history", history_default);
+app27.route("/api/v1/minds", minds_default);
+app27.route("/api/v1/minds", chat_default);
+app27.route("/api/v1/minds", typing_default);
+app27.route("/api/v1/minds", variants_default);
+app27.route("/api/v1/minds", files_default);
+app27.route("/api/v1/minds", env_default);
+app27.route("/api/v1/minds", mind_skills_default);
+app27.route("/api/v1/minds", schedules_default);
+app27.route("/api/v1/minds", logs_default);
+app27.route("/api/v1/system", system_default);
+app27.route("/api/v1/system", update_default);
+app27.route("/api/v1/prompts", prompts_default);
+app27.route("/api/v1/skills", skills_default);
+app27.route("/api/v1/env", sharedEnvApp);
+app27.route("/api/conversations", conversations_default);
+var app_default = app27;
 
 // src/web/server.ts
 import { existsSync as existsSync12 } from "fs";
@@ -8044,18 +8195,18 @@ async function startDaemon(opts) {
   } catch (err) {
     logger_default.warn("failed to initialize shared repo", logger_default.errorData(err));
   }
-  const { migrateSetupCompleted } = await import("./setup-SZIARWI6.js");
+  const { migrateSetupCompleted } = await import("./setup-TISPCO22.js");
   migrateSetupCompleted();
   await (await import("./db-F34YLV7D.js")).getDb();
   try {
-    const { eq: eq7, and: and5 } = await import("drizzle-orm");
+    const { eq: eq8, and: and6 } = await import("drizzle-orm");
     const { users: users2 } = await import("./schema-PA3M5ZKH.js");
     const db = await (await import("./db-F34YLV7D.js")).getDb();
-    await db.update(users2).set({ role: "system" }).where(and5(eq7(users2.user_type, "system"), eq7(users2.role, "user")));
+    await db.update(users2).set({ role: "system" }).where(and6(eq8(users2.user_type, "system"), eq8(users2.role, "user")));
   } catch (err) {
     logger_default.warn("failed to migrate system user role", logger_default.errorData(err));
   }
-  const { initSandbox } = await import("./sandbox-JANNTX6U.js");
+  const { initSandbox } = await import("./sandbox-GJOK4QLQ.js");
   await initSandbox();
   try {
     await syncBuiltinSkills();
@@ -8075,7 +8226,7 @@ async function startDaemon(opts) {
     logger_default.warn("failed to ensure #system channel", logger_default.errorData(err));
   }
   try {
-    const { getOrCreateSystemUser: getOrCreateSystemUser2 } = await import("./auth-6DMGES3I.js");
+    const { getOrCreateSystemUser: getOrCreateSystemUser2 } = await import("./auth-GKCDSO4T.js");
     await getOrCreateSystemUser2();
   } catch (err) {
     logger_default.warn(
@@ -8156,10 +8307,10 @@ async function startDaemon(opts) {
     await Promise.all(workers);
   }
   try {
-    const { isSetupComplete: isSetupComplete2 } = await import("./setup-SZIARWI6.js");
+    const { isSetupComplete: isSetupComplete2 } = await import("./setup-TISPCO22.js");
     if (isSetupComplete2()) {
-      const { ensureSpiritProject, syncSpiritTemplate } = await import("./spirit-N4W4UQRH.js");
-      const { startSpiritFull } = await import("./mind-service-AV273WT4.js");
+      const { ensureSpiritProject, syncSpiritTemplate } = await import("./spirit-VRONKFMF.js");
+      const { startSpiritFull } = await import("./mind-service-2MQ6UK5N.js");
       await ensureSpiritProject();
       await syncSpiritTemplate();
       const spiritEntry = await findMind("volute");
@@ -8176,7 +8327,7 @@ async function startDaemon(opts) {
   bridgeManager.startBridges(daemonPort).catch((err) => {
     logger_default.warn("failed to start bridges", logger_default.errorData(err));
   });
-  import("./cloud-sync-JN3NWKEM.js").then(
+  import("./cloud-sync-4NWLMFVH.js").then(
     ({ consumeQueuedMessages }) => consumeQueuedMessages().catch((err) => {
       logger_default.warn("failed to consume queued cloud messages", logger_default.errorData(err));
     })
@@ -8184,7 +8335,7 @@ async function startDaemon(opts) {
     logger_default.warn("failed to load cloud-sync module", logger_default.errorData(err));
   });
   try {
-    const { backfillTemplateHashes, notifyVersionUpdate } = await import("./version-notify-TCKWBZZG.js");
+    const { backfillTemplateHashes, notifyVersionUpdate } = await import("./version-notify-NBI2MTJO.js");
     backfillTemplateHashes();
     notifyVersionUpdate().catch((err) => {
       logger_default.warn("failed to send version update notifications", logger_default.errorData(err));